【JetPack-四】Room与数据库学习笔记，简单MVVM（Kotlin）

最新推荐文章于 2024-04-09 02:44:35 发布

风聆Mia

最新推荐文章于 2024-04-09 02:44:35 发布

阅读量544

点赞数

分类专栏： Android-JetPack

本文链接：https://blog.csdn.net/qq_38304672/article/details/106690510

版权

Android-JetPack 专栏收录该内容

3 篇文章 1 订阅

订阅专栏

学习视频来源:

https://www.bilibili.com/video/BV1sJ41127EMlongway777
模型图来源也全截取来自该Up的视频

一.Boat

通过建立Repository进行解耦

1. Entity，行，实体，定义了表格结构

在这里插入图片描述

2. 添加Room依赖

先添加kapt的插件依赖
按需导入

3. 代码一：通过Dao，Entity和Database建立简单数据库，进行增删改查

1. 建立word类，数据库字段和Bean类里是映射关系，必须一致

java式
kotlin
kotlin加入get和set方法


@Entity//Room表示创建实体类
class Word(word: String, chineseMeaning: String) {
    @PrimaryKey(autoGenerate = true)
    private var id = 0

    @ColumnInfo(name = "english_word")
    private var word: String
    @ColumnInfo(name = "chinese_meaning")
    private var chineseMeaning: String

    fun getId(): Int {
        return id
    }

    fun setId(id: Int) {
        this.id = id
    }

    fun getWord(): String {
        return word
    }

    fun setWord(word: String) {
        this.word = word
    }

    fun getChineseMeaning(): String {
        return chineseMeaning
    }

    fun setChineseMeaning(chineseMeaning: String) {
        this.chineseMeaning = chineseMeaning
    }

    init {
        this.word = word
        this.chineseMeaning = chineseMeaning
    }
}

2. 建立wordDao类

java写法，接收多个参数，insert java写法可返回当前id
kotlin写法
补充dao层接口

interface WordDao {

    @Insert
    fun insertWords(vararg words: Word?)

    @Update//返回修改的记录条数
    fun updateWords(vararg words: Word?) //通过id进行替换内容

    @Delete
    fun deleteWords(vararg words: Word?)

    @Query("DELETE FROM WORD")//删除所有内容
    fun deleteAllWords();

    @Query("SELECT * FROM WORD ORDER BY ID DESC")//降序查询
    fun getAllWords():List<Word>
}

建立Database
java式写法
注意kotlin式

3. MainActivity【实测单声明不加insert则不会创建数据库】

声明database（数据库名称）与dao对象
试图绑定一个text和4个button与监听事件即可

class MainActivity : AppCompatActivity() {

    private var worddatabase:WordDatabase?=null
    lateinit var worddao: WordDao

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        worddatabase= Room.databaseBuilder( this,WordDatabase::class.java,"word_database")
                .allowMainThreadQueries().build()//强制主线程运行 但不太好
        worddao= worddatabase?.getWordDao()!!


        button_insert.setOnClickListener {
            var word:Word = Word("Hello","你好")
            var word1:Word = Word("ByeBye","再见")
            worddao.insertWords(word1,word)
            updateView();
        }
        button_delete.setOnClickListener {
            var word:Word = Word("Word","世界")
            word.setId(40)
            worddao.deleteWords(word)
            updateView()
        }
        button_clear.setOnClickListener{
            worddao.deleteAllWords()
            updateView()
        }
        button_update.setOnClickListener {
            var word:Word = Word("Word","世界")
            word.setId(40)
            worddao.updateWords(word)
            updateView()
        }

    }

    fun updateView(){
        var list:List<Word> =worddao.getAllWords()
        var text=""

        for (i in (0 until list.size)){
            var word:Word =list.get(i)
            text+=""+word.getId()+":"+word.getWord()+"="+word.getChineseMeaning();
        }
        text2.text=text
    }
}

4. 查看存储位置与导出表

在这里插入图片描述

4. 代码二:JetPack融入(LiveData)，线程控制(AsyncTask)，SingleTon与仓库类，结合ViewModel精简

在这里插入图片描述

1. LiveData

将查询的返回值改为LiveData，PS：返回的livedata比较特殊,会自动放入副线程，所以之后不用封装单独线程方法
增删改查原本都要调用updateView方法进行更新界面，现在通过观察者模式，观察总数据，若总数据产生变动,则会自动调用更新方法
lifedata观察者模式，将原本代码中所以的updateview删除，lifedata在处理多处会调用UI相同操作的地方很好用。完成插入删除后界面自动刷新

        allwordslive=worddao.getAllWordsLive()
        updateView();
        allwordslive.observe(this,object: Observer<List<Word>>{
            override fun onChanged(t: List<Word>?) {
                var text=""

                if (t != null) {
                    for (i in (0 until t.size)){
                        var word:Word =t.get(i)
                        text+=""+word.getId()+":"+word.getWord()+"="+word.getChineseMeaning()+"\n";
                    }
                }
                text2.text=text
            }

        })

2. 单例模式Singleton与抽象类的静态方法。

建立INSTANCE单例
@Synchronized关键字
抽象类的静态方法用open关键字修饰


@Database(entities = [Word::class],version = 1,exportSchema = false)
 abstract class WordDatabase: RoomDatabase() {
    //若有多个entities则返回多个Dao
    
    companion object{
        private var INSTANCE: WordDatabase? = null
        @Synchronized//如果有多个客户端  且同时instance时保证不会有碰撞 只有一个instance生成
        open  fun  getDatabase(context: Context): WordDatabase? {//静态类的静态方法写open
            if (INSTANCE==null){
                INSTANCE=Room.databaseBuilder(context.applicationContext,WordDatabase::class.java,"word_database")
                    .build()
            }
            return INSTANCE
        }
    }


    abstract fun getWordDao(): WordDao
}

2.5. 建立工作线程/后期优化进入单独文件

使用AsyncTask，写Player的时候优化查询前用过
新建插入线程，后两个参数分别是报告进度和报告结果，使用构造函数传递一个结果

    internal class InsertAsyncTask(private val worddao: WordDao) : AsyncTask<Word?, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Word?) {
           publishProgress()//该方法用于一段时间报告工作进度
           worddao.insertWords(*params)
        }
        //将结果带回给主线程
        override fun onPostExecute(result: Unit?) {
            super.onPostExecute(result)
        }
        //进度发送更新时
        override fun onProgressUpdate(vararg values: Unit?) {
            super.onProgressUpdate(*values)
        }
        //后台工作开始之前反馈
        override fun onPreExecute() {
            super.onPreExecute()
        }

    }

保留doinbackground，建立增删改查


    internal class InsertAsyncTask(private val worddao: WordDao) : AsyncTask<Word?, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Word?) {
           publishProgress()//该方法用于一段时间报告工作进度
           worddao.insertWords(*params)
        }
    }
    internal class UpdateAsyncTask(private val worddao: WordDao) : AsyncTask<Word?, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Word?) {
            publishProgress()//该方法用于一段时间报告工作进度
            worddao.updateWords(*params)
        }
    }
    internal class DeleteAsyncTask(private val worddao: WordDao) : AsyncTask<Word?, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Word?) {
            publishProgress()//该方法用于一段时间报告工作进度
            worddao.deleteWords(*params)
        }
    }
    internal class DeleteAllAsyncTask(private val worddao: WordDao) : AsyncTask<Unit, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Unit?) {
            publishProgress()//该方法用于一段时间报告工作进度
            worddao.deleteAllWords()
        }
    }

取代原数据库语句调用操作，以insert为例，替换后把.allowMainThreadQueries()去掉即可。

3. 抽取MVVM

建立WordViewModel，使用主构造器与init初始化（因为getDatabase()进行单例创建时需要context），进行数据库创建与dao层相关的生成。
建立LiveData类存储List用于MainAC观察者的监听，并写对应方法
将MAC封装的Async方法移植过来，抽取方法，MAC新建ViewModel对象时直接可以调用。
1）

class WordViewModel(application: Application) : AndroidViewModel(application){
    private lateinit var allwordslive :LiveData<List<Word>>
    lateinit var worddatabase: WordDatabase
    private lateinit var worddao:WordDao


    init{
        worddatabase= WordDatabase.getDatabase(application)!!
        worddao= worddatabase?.getWordDao()
        allwordslive=worddao.getAllWordsLive()

    }

    public fun getAllWordsLive():LiveData<List<Word>>{
        return allwordslive
    }
    //写方法调用这些
    fun insertWords(vararg params: Word?){
        InsertAsyncTask(worddao).execute(*params)
    }
    fun updateWords(vararg params: Word?){
        UpdateAsyncTask(worddao).execute(*params)
    }
    fun deleteWords(vararg params: Word?){
        DeleteAsyncTask(worddao).execute(*params)
    }
    fun deleteAllWords(vararg params: Word?){
        DeleteAllAsyncTask(worddao).execute()
    }




    internal class InsertAsyncTask(private val worddao: WordDao) : AsyncTask<Word?, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Word?) {
            publishProgress()//该方法用于一段时间报告工作进度
            worddao.insertWords(*params)
        }
    }
    internal class UpdateAsyncTask(private val worddao: WordDao) : AsyncTask<Word?, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Word?) {
            publishProgress()//该方法用于一段时间报告工作进度
            worddao.updateWords(*params)
        }
    }
    internal class DeleteAsyncTask(private val worddao: WordDao) : AsyncTask<Word?, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Word?) {
            publishProgress()//该方法用于一段时间报告工作进度
            worddao.deleteWords(*params)
        }
    }
    internal class DeleteAllAsyncTask(private val worddao: WordDao) : AsyncTask<Unit, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Unit?) {
            publishProgress()//该方法用于一段时间报告工作进度
            worddao.deleteAllWords()
        }
    }

}

2）MAC修改

class MainActivity : AppCompatActivity() {
   /* private var worddatabase:WordDatabase?=null*/
   /* lateinit var worddao: WordDao*/
/*    lateinit var allwordslive:LiveData<List<Word>>*/
    //创建Viewmodel实例
    lateinit var wordviewmodel: WordViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        wordviewmodel=ViewModelProvider(this).get(WordViewModel::class.java)

     /*   worddatabase= Room.databaseBuilder( this,WordDatabase::class.java,"word_database")
                .build()//强制主线程运行 但不太好*/
   /*     worddao= worddatabase?.getWordDao()!!*/


  /*      allwordslive=worddao.getAllWordsLive()*/

        wordviewmodel.getAllWordsLive().observe(this,object: Observer<List<Word>>{
            override fun onChanged(t: List<Word>?) {
                var text=""

                if (t != null) {
                    for (i in (0 until t.size)){
                        var word:Word =t.get(i)
                        text+=""+word.getId()+":"+word.getWord()+"="+word.getChineseMeaning()+"\n";
                    }
                }
                text2.text=text
            }

        })

        button_insert.setOnClickListener {
            var word:Word = Word("Hello","你好")
            var word1:Word = Word("ByeBye","再见")
            //worddao.insertWords(word1,word)
            wordviewmodel.insertWords(word1,word)//副线程的插入

        }
        button_delete.setOnClickListener {
            var word:Word = Word("Word","世界")
            word.setId(40)
            //worddao.deleteWords(word)
            wordviewmodel.deleteWords(word)

        }
        button_clear.setOnClickListener{
            wordviewmodel.deleteAllWords()//副线程的插入

        }
        button_update.setOnClickListener {
            var word:Word = Word("Word","世界")
            word.setId(40)
            //worddao.updateWords(word)
            wordviewmodel.updateWords(word)//副线程的插入
        }
    }
    
}

点击运行一切正常

4.数据的获取不是ViewModel的职责，优化ViewModel，创建仓库类作为数据的中介。

建立WordRepository(作为model)

//用于本地/云端数据库获取数据
class WordRepository(context: Context) {
    private var allwordslive : LiveData<List<Word>>
    private  var worddao:WordDao
    var worddatabase: WordDatabase = WordDatabase.getDatabase(context.applicationContext)!!

    init {
        worddao= worddatabase.getWordDao()
        allwordslive=worddao.getAllWordsLive()
    }
    

    //写接口调用这些
    fun insertWords(vararg params: Word?){
        InsertAsyncTask(worddao).execute(*params)
    }
    fun updateWords(vararg params: Word?){
        UpdateAsyncTask(worddao).execute(*params)
    }
    fun deleteWords(vararg params: Word?){
        DeleteAsyncTask(worddao).execute(*params)
    }
    fun deleteAllWords(){
        DeleteAllAsyncTask(worddao).execute()
    }

    fun getAllWordsLive():LiveData<List<Word>>{
        return allwordslive
    }


    internal class InsertAsyncTask(private val worddao: WordDao) : AsyncTask<Word?, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Word?) {
            publishProgress()//该方法用于一段时间报告工作进度
            worddao.insertWords(*params)
        }
    }
    internal class UpdateAsyncTask(private val worddao: WordDao) : AsyncTask<Word?, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Word?) {
            publishProgress()//该方法用于一段时间报告工作进度
            worddao.updateWords(*params)
        }
    }
    internal class DeleteAsyncTask(private val worddao: WordDao) : AsyncTask<Word?, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Word?) {
            publishProgress()//该方法用于一段时间报告工作进度
            worddao.deleteWords(*params)
        }
    }
    internal class DeleteAllAsyncTask(private val worddao: WordDao) : AsyncTask<Unit, Unit, Unit>(){
        //在后台工作
        override fun doInBackground(vararg params: Unit?) {
            publishProgress()//该方法用于一段时间报告工作进度
            worddao.deleteAllWords()
        }
    }

}

修改ViewModel

class WordViewModel(application: Application) : AndroidViewModel(application){
    
    private var wordrepository:WordRepository = WordRepository(application)
    
    fun getAllWordsLive():LiveData<List<Word>>{
        return wordrepository.getAllWordsLive()
    }
    //写接口调用这些
    fun insertWords(vararg params: Word?){
        wordrepository.insertWords(*params)
    }
    fun updateWords(vararg params: Word?){
        wordrepository.updateWords(*params)
    }
    fun deleteWords(vararg params: Word?){
        wordrepository.deleteWords(*params)
    }
    fun deleteAllWords(){
        wordrepository.deleteAllWords()
    }

    
}

MainActivity不变

class MainActivity : AppCompatActivity() {

    //创建Viewmodel实例
    lateinit var wordviewmodel: WordViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        wordviewmodel=ViewModelProvider(this).get(WordViewModel::class.java)



        wordviewmodel.getAllWordsLive().observe(this,object: Observer<List<Word>>{
            override fun onChanged(t: List<Word>?) {
                var text=""

                if (t != null) {
                    for (i in (0 until t.size)){
                        var word:Word =t.get(i)
                        text+=""+word.getId()+":"+word.getWord()+"="+word.getChineseMeaning()+"\n";
                    }
                }
                text2.text=text
            }

        })

        button_insert.setOnClickListener {
            var word:Word = Word("Hello","你好")
            var word1:Word = Word("ByeBye","再见")
            //worddao.insertWords(word1,word)
            wordviewmodel.insertWords(word1,word)//副线程的插入

        }
        button_delete.setOnClickListener {
            var word:Word = Word("Word","世界")
            word.setId(40)
            //worddao.deleteWords(word)
            wordviewmodel.deleteWords(word)

        }
        button_clear.setOnClickListener{
            wordviewmodel.deleteAllWords()//副线程的插入

        }
        button_update.setOnClickListener {
            var word:Word = Word("Word","世界")
            word.setId(40)
            //worddao.updateWords(word)
            wordviewmodel.updateWords(word)//副线程的插入
        }
    }

}

精简后MainActivity仅持有ViewModel对象和UI监听，更新，其余所以操作交给ViewModel' ；ViewModel持有Repository对象，及调用其方法；所有数据存储实体及数据库操作都在Repository类中。
4.

package com.ywjh.farawaymia.data;

import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;


import com.ywjh.farawaymia.App;
import com.ywjh.farawaymia.model.AudioBean;

import java.util.ArrayList;
import java.util.List;

public class HistoryDao implements IHistoryDao {

    private static final String TAG = "HistoryDao";
    private final XimalayaDBHelper mDbHelper;
    private IHistoryDaoCallback mCallback = null;
    private final Object mLock = new Object();

    public HistoryDao() {
        mDbHelper = new XimalayaDBHelper(App.Companion.getCONTEXT());
    }

    @Override
    public void setCallback(IHistoryDaoCallback callback) {
        this.mCallback = callback;
    }

    @Override
    public void addHistory(AudioBean itembean) {

        synchronized(mLock) {
            SQLiteDatabase db = null;
            boolean isSuccess = false;
            try {
                db = mDbHelper.getWritableDatabase();
                //先去删除 解决重复问题
                int deleteresult=db.delete(Constants.HISTORY_TB_NAME,Constants.HISTORY_TITLE + "=?",new String[]{itembean.getTitle() + ""});
               /* System.out.println("1111111111"+deleteresult);*/
                //删除以后再添加
                //1.手动设置开始事务
                db.beginTransaction();
                ContentValues values = new ContentValues();
                //封装数据

                values.put(Constants.HISTORY_Album_ID,itembean.getAlbumid());
                values.put(Constants.HISTORY_MUSIC_ID,itembean.getMusicId());
                values.put(Constants.HISTORY_YEAR,itembean.getYear());
                values.put(Constants.HISTORY_TITLE,itembean.getTitle());
                values.put(Constants.HISTORY_ARTIST,itembean.getArtist());
                values.put(Constants.HISTORY_DURATION,itembean.getDuration());
                values.put(Constants.HISTORY_Size,itembean.getSize());
                values.put(Constants.HISTORY_Album,itembean.getAlbum());
                values.put(Constants.HISTORY_DATA,itembean.getData());

                //插入数据
                db.insert(Constants.HISTORY_TB_NAME,null,values);
                //2.数据操作完成
                db.setTransactionSuccessful();
                isSuccess = true;
            } catch(Exception e) {
                isSuccess = false;
                e.printStackTrace();//日志输出
            } finally {
                if(db != null) {
                    //3. 处理完成 检查并提交事务
                     db.endTransaction();
                    db.close();
                }
                if(mCallback != null) {
                    mCallback.onHistoryAdd(isSuccess);
                }
            }
        }
    }

    @Override
    public void delHistory(AudioBean itembean) {
        synchronized(mLock) {
            SQLiteDatabase db = null;
            boolean isDeleteSuccess = false;
            try {
                db = mDbHelper.getWritableDatabase();
                db.beginTransaction();
                //System.out.println("11111111111111delete"+itembean.getTitle());
                int delete = db.delete(Constants.HISTORY_TB_NAME,Constants.HISTORY_MUSIC_ID+ "=?",new String[]{itembean.getMusicId() + ""});
                //测试30首歌删除干开始是成功的  处理回调
                //System.out.println("11111111111111delete"+delete);

                db.setTransactionSuccessful();
                isDeleteSuccess = true;
            } catch(Exception e) {
                e.printStackTrace();
                isDeleteSuccess = false;
            } finally {
                if(db != null) {
                    db.endTransaction();
                    db.close();
                }
                if(mCallback != null) {
                    mCallback.onHistoryDel(isDeleteSuccess);
                }
            }
        }
    }


    @Override
    public void clearHistory() {
        synchronized(mLock) {
            SQLiteDatabase db = null;
            boolean isDeleteSuccess = false;
            try {
                db = mDbHelper.getWritableDatabase();
                db.beginTransaction();
                db.delete(Constants.HISTORY_TB_NAME,null,null);
                db.setTransactionSuccessful();
                isDeleteSuccess = true;
            } catch(Exception e) {
                e.printStackTrace();
                isDeleteSuccess = false;
            } finally {
                if(db != null) {
                    db.endTransaction();
                    db.close();
                }
                if(mCallback != null) {
                    mCallback.onHistoriesClean(isDeleteSuccess);
                }
            }
        }
    }

    @Override
    public void listHistories() {
        synchronized(mLock) {
            //从数据表中查出所有的历史记录
            SQLiteDatabase db = null;
            ArrayList<AudioBean> histories = new ArrayList<>();
            try {
                db = mDbHelper.getReadableDatabase();
                db.beginTransaction();
                Cursor cursor = db.query(Constants.HISTORY_TB_NAME,null,null,null,null,null,"_id desc");
                while(cursor.moveToNext()) {
                    AudioBean itembean = new AudioBean((long) 0,"","",0,"","","","",0,"");

                    long musicId=cursor.getLong(cursor.getColumnIndex(Constants.HISTORY_MUSIC_ID));
                    itembean.setMusicId(musicId);
                    String year = cursor.getString(cursor.getColumnIndex(Constants.HISTORY_YEAR));
                    itembean.setTitle(year);
                    long albumId = cursor.getLong(cursor.getColumnIndex(Constants.HISTORY_Album_ID));
                    itembean.setAlbumid(albumId);
                    String title = cursor.getString(cursor.getColumnIndex(Constants.HISTORY_TITLE));
                    itembean.setTitle(title);
                    String artist = cursor.getString(cursor.getColumnIndex(Constants.HISTORY_ARTIST));
                    itembean.setArtist(artist);
                    String duration = cursor.getString(cursor.getColumnIndex(Constants.HISTORY_DURATION));
                    itembean.setDuration(duration);
                    long size = cursor.getLong(cursor.getColumnIndex(Constants.HISTORY_Size));
                    itembean.setSize(size);
                    String album = cursor.getString(cursor.getColumnIndex(Constants.HISTORY_Album));
                    itembean.setAlbum(album);

                    String data = cursor.getString(cursor.getColumnIndex(Constants.HISTORY_DATA));

                    itembean.setData(data);
                    histories.add(itembean);
                }
                db.setTransactionSuccessful();
            } catch(Exception e) {
                e.printStackTrace();
            } finally {
                if(db != null) {
                    db.endTransaction();
                    db.close();
                }
                //通知出去
                if(mCallback != null) {//查询完成后通知结果
                    mCallback.onHistoriesLoaded(histories);
                }
            }
        }
    }
}