能否将原生SQLite与Android ViewModel搭配使用？ViewModel仅适配Room吗？

Great question! Let me break this down clearly for you:

Short Answer #

Absolutely yes, you can use raw SQLite with ViewModel, and ViewModel is definitely not designed exclusively for Room. Its core purpose is to retain data across configuration changes (like screen rotations) and decouple the UI layer from data logic—this has nothing to do with which persistence library you use.

How to Integrate Raw SQLite with ViewModel #

Here’s a practical, step-by-step approach to migrate from Loaders to ViewModel while keeping your existing SQLite code intact:

1. Wrap SQLite Logic in a Repository
   Extract all your SQLite operations (queries, inserts, updates, deletes) from Activities/Fragments into a dedicated Repository class. This follows the MVVM pattern, keeps your UI code clean, and centralizes data access logic. The Repository will handle all direct interactions with SQLiteOpenHelper or SQLiteDatabase.

2. Use ViewModel to Hold Data & Business Logic
   Create a ViewModel class that holds an instance of your Repository. The ViewModel’s job is to expose data to the UI (via LiveData, for lifecycle-aware updates) and handle business logic—all while surviving configuration changes. You won’t have to re-query the database after a screen rotation because the ViewModel retains its state.

3. Handle Async Operations Properly
   Replace LoaderManager’s async loading with modern alternatives like Kotlin Coroutines, RxJava, or even AsyncTask (though it’s officially deprecated, it can still work for legacy code). Perform all SQLite operations on a background thread, then post results to the main thread using LiveData so the UI can update safely.

Example Code Snippet #

Repository Class (Wraps Raw SQLite)

class UserRepository(private val dbHelper: MyCustomDbHelper) {
    fun getUsers(): LiveData<List<User>> {
        val userLiveData = MutableLiveData<List<User>>()

        // Use Coroutines for background execution
        CoroutineScope(Dispatchers.IO).launch {
            val cursor = dbHelper.readableDatabase.query(
                "users",
                null, null, null, null, null, null
            )

            val users = mutableListOf<User>()
            while (cursor.moveToNext()) {
                val user = User(
                    id = cursor.getInt(cursor.getColumnIndexOrThrow("id")),
                    name = cursor.getString(cursor.getColumnIndexOrThrow("name"))
                )
                users.add(user)
            }
            cursor.close()

            // Switch to main thread to update LiveData
            withContext(Dispatchers.Main) {
                userLiveData.value = users
            }
        }

        return userLiveData
    }

    // Add other methods like insertUser(), updateUser(), etc.
    suspend fun insertUser(user: User) {
        val db = dbHelper.writableDatabase
        val values = ContentValues().apply {
            put("name", user.name)
        }
        db.insert("users", null, values)
        db.close()
    }
}

ViewModel Class

class UserViewModel(private val repository: UserRepository) : ViewModel() {
    // Expose LiveData for the UI to observe
    val users: LiveData<List<User>> = repository.getUsers()

    // Delegate operations to the Repository
    fun addUser(user: User) {
        CoroutineScope(Dispatchers.IO).launch {
            repository.insertUser(user)
        }
    }
}

Activity/Fragment Integration

class UserListActivity : AppCompatActivity() {
    private lateinit var userViewModel: UserViewModel

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

        // Initialize your SQLite helper and repository
        val dbHelper = MyCustomDbHelper(this)
        val repository = UserRepository(dbHelper)

        // Get ViewModel instance (survives configuration changes)
        userViewModel = ViewModelProvider(this, object : ViewModelProvider.Factory {
            override fun <T : ViewModel> create(modelClass: Class<T>): T {
                return UserViewModel(repository) as T
            }
        })[UserViewModel::class.java]

        // Observe LiveData to update UI
        userViewModel.users.observe(this) { users ->
            // Update RecyclerView or other UI components here
            updateUserList(users)
        }
    }
}

Key Takeaways #

• ViewModel’s core value is lifecycle-aware data retention and separation of concerns—not tight coupling with Room.
• By wrapping your raw SQLite code in a Repository and using ViewModel + LiveData, you’ll get the same (if not better) benefits as LoaderManager, with cleaner, more maintainable code.
• You don’t need to rewrite your entire database layer to use ViewModel—just refactor how you access and expose data to the UI.

内容的提问来源于stack exchange，提问作者Urchboy