1
2
3
4
5
6
7
8
9
10
buildscript {
    //android room version
    ext.room_version = '2.3.0'
}
// room
implementation "androidx.room:room-runtime:$room_version"
kapt "androidx.room:room-compiler:$room_version"
// optional - room kotlin 扩展
implementation "androidx.room:room-ktx:$room_version"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
class SimpleViewModel(private val simpleStudentDao: SimpleStudentDao) : ViewModel() {

    fun insertStudent(studentEntity: SimpleStudentEntity) {
        viewModelScope.launch(Dispatchers.Default) {
            simpleStudentDao.insertStudent(studentEntity)
        }
    }

    fun insertStudentAll(studentEntity: List<SimpleStudentEntity>) {
        viewModelScope.launch(Dispatchers.Default) {
            simpleStudentDao.insertStudentAll(studentEntity)
        }
    }

    fun deleteStudent(studentEntity: SimpleStudentEntity) {
        viewModelScope.launch(Dispatchers.Default) {
            simpleStudentDao.deleteStudent(studentEntity)
        }
    }

    fun updateStudent(studentEntity: SimpleStudentEntity) {
        viewModelScope.launch(Dispatchers.Default) {
            simpleStudentDao.updateStudent(studentEntity)
        }
    }

    suspend fun getStudentAll(): List<SimpleStudentEntity> {
        //使用主从作用域
        return supervisorScope {
            val students = async(Dispatchers.IO) {
                simpleStudentDao.getStudentAll()
            }
            students.await()
        }
    }

    suspend fun getStudentById(id: Int): List<SimpleStudentEntity> {
        //使用主从作用域
        return supervisorScope {
            val students = async(Dispatchers.IO) {
                simpleStudentDao.getStudentById(id)
            }
            students.await()
        }
    }


    override fun onCleared() {
        super.onCleared()

    }
}

/**
 * 自定义工厂，可传入Dao参数
 */
class MyViewModelFactory(private val dao: SimpleStudentDao) : ViewModelProvider.Factory {
    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
        if (modelClass.isAssignableFrom(SimpleViewModel::class.java)) {
            @Suppress("UNCHECKED_CAST")
            return SimpleViewModel(dao) as T
        }
        throw IllegalArgumentException("Unknown ViewModel class.")
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
class SimpleRoomDemoActivity : AppCompatActivity() {

    /**
     * binding 
     */
    private var _binding: ActivitySimpleUseRoomBinding? = null
    private val binding get() = _binding!!

    /**
     * 数据库dao
     */
    private val simpleDao: SimpleStudentDao by lazy(LazyThreadSafetyMode.NONE) {
        SimpleMyDataBase.getDataBase().simpleStudentDao()
    }

    /**
     * viewModel
     */
    lateinit var viewModel: SimpleViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        _binding = ActivitySimpleUseRoomBinding.inflate(layoutInflater)
        setContentView(binding.root)
        initParam()
        initView()
    }

    private fun initParam() {
        viewModel = ViewModelProvider(
            this,
            //传入自己的工厂
            MyViewModelFactory(simpleDao)
        )[SimpleViewModel::class.java]
    }

    private fun initView() {
        with(binding) {
            btnInsert.setOnClickListener {
                viewModel.insertStudent(SimpleStudentEntity(0, "zxf", "18"))
            }
            btnInsertAll.setOnClickListener {
                viewModel.insertStudentAll(
                    arrayListOf(
                        SimpleStudentEntity(0, "liSi", "18"),
                        SimpleStudentEntity(0, "wangWu", "18")
                    )
                )
            }
            //delete 和 update 是根据什么来的  看了源码生成的sql默认根据主键来的
            btnDelete.setOnClickListener {
                viewModel.deleteStudent(SimpleStudentEntity(2, "delete", "99"))
//                viewModel.deleteStudent(SimpleStudentEntity(199,"update","99"))
            }
            btnUpdate.setOnClickListener {
                //所以我们这里面可以直接写一个默认的id去设置,不需要非要拿到查询的对象
//                viewModel.updateStudent(SimpleStudentEntity(1,"update","99"))
                viewModel.updateStudent(SimpleStudentEntity(199, "update", "99"))
            }
            //看了一下查询生成的源代码，对于对象来说直接new了，所以不会返回null，但是对象的值，没有就是null，需要声明为可null类型
            btnGetId.setOnClickListener {
                lifecycleScope.launch {
                    displayToTextView(viewModel.getStudentById(5))
                }
            }
            btnGetAll.setOnClickListener {
                lifecycleScope.launch {
                    displayToTextView(viewModel.getStudentAll())
                }
            }
        }
    }

    private fun displayToTextView(students: List<SimpleStudentEntity>) {
        val string = students.joinToString(
            """
            
        """.trimIndent()
        )
        binding.text.text = string
    }

    /**
     * 释放binding
     */
    override fun onDestroy() {
        super.onDestroy()
        _binding = null
    }
}

1
2
3
4
5
6
7
8
9
10
11
public void insertStudent(final SimpleStudentEntity studentEntity) {
	__db.assertNotSuspendingTransaction();
	__db.beginTransaction();
	try {
		__insertionAdapterOfSimpleStudentEntity.insert(studentEntity);
		__db.setTransactionSuccessful();
	} finally {
    __db.endTransaction();
	}
}

1
2
3
4
5
6
7
8
9
10
11
public void beginTransaction() {
	assertNotMainThread();
    ...
}
public void assertNotMainThread() {
    ...
    if (isMainThread()) {
        throw new IllegalStateException("Cannot access database on the main thread 			since it may potentially lock the UI for a long period of time.");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public List<SimpleStudentEntity> getStudentAll() {
    final String _sql = "select * from simple_student";
    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
    __db.assertNotSuspendingTransaction();
    final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
    try {
      final int _cursorIndexOfId = CursorUtil.getColumnIndexOrThrow(_cursor, "student_id");
      final int _cursorIndexOfName = CursorUtil.getColumnIndexOrThrow(_cursor, "student_name");
      final int _cursorIndexOfAge = CursorUtil.getColumnIndexOrThrow(_cursor, "student_age");
      final List<SimpleStudentEntity> _result = new ArrayList<SimpleStudentEntity>(_cursor.getCount());
      while(_cursor.moveToNext()) {
        final SimpleStudentEntity _item;
        final int _tmpId;
        _tmpId = _cursor.getInt(_cursorIndexOfId);
        final String _tmpName;
        if (_cursor.isNull(_cursorIndexOfName)) {
          _tmpName = null;
        } else {
          _tmpName = _cursor.getString(_cursorIndexOfName);
        }
        final String _tmpAge;
        if (_cursor.isNull(_cursorIndexOfAge)) {
          _tmpAge = null;
        } else {
          _tmpAge = _cursor.getString(_cursorIndexOfAge);
        }
        _item = new SimpleStudentEntity(_tmpId,_tmpName,_tmpAge);
        _result.add(_item);
      }
      return _result;
    } finally {
      _cursor.close();
      _statement.release();
    }
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  public void deleteStudent(final SimpleStudentEntity studentEntity) {
    ...
    try {
      __deletionAdapterOfSimpleStudentEntity.handle(studentEntity);
      __db.setTransactionSuccessful();
    }
    ...
  }
    this.__deletionAdapterOfSimpleStudentEntity = new EntityDeletionOrUpdateAdapter<SimpleStudentEntity>(__db) {
      @Override
      public String createQuery() {
        return "DELETE FROM `simple_student` WHERE `student_id` = ?";
      }

      @Override
      public void bind(SupportSQLiteStatement stmt, SimpleStudentEntity value) {
        stmt.bindLong(1, value.getId());
      }
    };