Android Developer Roadmap: Lựa Chọn Kiến Trúc Phù Hợp Cho Ứng Dụng Android – MVC, MVP, MVVM, Hay MVI?

Niềm tin cần bỏ: chọn đúng một trong bốn chữ viết tắt MVC, MVP, MVVM, MVI là xong phần kiến trúc. Sai. Thứ quyết định một app Android còn bảo trì được sau ba năm là ranh giới giữa các lớp và hướng dữ liệu chảy, không phải cái tên pattern. Bạn có thể viết MVVM mà vẫn ra một Activity khổng lồ, hoặc viết MVC gọn gàng trong một app nhỏ. Bài này giải thích bốn mô hình bằng sơ đồ nhỏ, rồi chốt lựa chọn thực dụng cho 2026: MVVM + luồng một chiều + repository, và MVI khi state chuyển tiếp phức tạp.

Cập nhật 2026: nền tảng đã đổi, pattern thì không

  • Lifecycle 2.11.0 (stable 2026-06-17, hỗ trợ KMP) là nền của ViewModel, SavedStateHandle và collectAsStateWithLifecycle().
  • Compose BOM 2026.09.00 (runtime/ui/foundation 1.12.1, Material 3 1.4.0) là mặc định cho UI mới; XML/Views vẫn hỗ trợ đầy đủ cho màn hình cũ.
  • Hilt 2.60.1 với KSP2: KAPT không còn trên đường chính, và @HiltViewModel là cách inject ViewModel chuẩn.
  • StateFlow là mặc định thay LiveData trong app Kotlin/Compose; Navigation 3 1.2.1 stable, còn Navigation 2 chỉ nhận bản vá lỗi.

Ba lớp, một chiều: mô hình tư duy trước khi chọn tên

Mọi pattern trong bài trả lời cùng một câu hỏi: ai giữ state, ai được sửa state, và state tới UI bằng đường nào. Trước khi tranh luận tên gọi, hãy vẽ ba lớp và kiểm tra code của bạn có vi phạm ranh giới nào không.

Lớp Chứa gì Không được chứa
UI Composable hoặc View, render state, phát event Business rule, gọi API trực tiếp, tự biến đổi dữ liệu
Domain (tuỳ chọn) Use case, model thuần, quy tắc nghiệp vụ Context, Android framework, annotation của Room
Data Repository, DAO, Retrofit, DataStore State UI, Composable, quyết định hiển thị

Với app nhỏ, domain có thể chỉ là vài hàm trong repository — đừng tạo use case rỗng để “đủ tầng”. Khi có quy tắc thật (giá, tồn kho, phân quyền), tách domain để test mà không cần Room hay Retrofit.

State đi xuống, event đi lên

UI không tự quyết định hiển thị gì: nó nhận UiState bất biến và vẽ. Mọi thứ người dùng làm — bấm, gõ, kéo — là event gửi lên ViewModel. Giữ đúng một chiều thì bug “hai nguồn sự thật” biến mất, vì ngoài ViewModel không ai sửa state.

UiState: data class hay sealed interface?

Dùng sealed interface khi các trạng thái loại trừ nhau: Loading, Content, Error — mỗi lúc chỉ một trạng thái đúng. Dùng data class khi các phần state tồn tại song song và copy() là cách cập nhật: isRefreshing, items, query. Đừng ép mọi thứ thành sealed; màn hình có 12 nhánh sealed thường là dấu hiệu state chưa được mô hình hoá đúng. Ngược lại, data class với 15 field nullable là sealed interface viết sai cách.

Bốn mô hình, bốn sơ đồ nhỏ

MVC: Activity làm Controller, và đó chính là vấn đề

Activity  =  Controller + View + một phần Model
   ├── inflate XML, findViewById, set text
   ├── gọi API / query database
   └── tính business rule, format dữ liệu

Trong MVC “sách giáo khoa”, View là XML, Model là dữ liệu, Controller là Activity. Nhưng Activity vừa nhận sự kiện, vừa cập nhật View, vừa gọi Model — ba vai trong một object. Kết quả là god object: 800 dòng, không unit-test được vì phải chạy Robolectric hoặc thiết bị thật, và mọi thay đổi nhỏ đều chạm cùng một file. MVC không sai về lý thuyết; nó chỉ không khớp với việc Activity là nơi Android trao lifecycle, window và input.

MVP: Presenter tách được, nhưng trả giá bằng interface

View (Activity, passive) ──event──▶ Presenter ──▶ Model
        ◀── callback qua View interface ──┘

MVP sửa được vấn đề testability: Presenter là class Kotlin thuần, mock View interface là test được logic. Cái giá là contract interface hai chiều, attachView()/detachView() gọi thủ công, mỗi màn hình thành ba file. Quên detach thì leak; callback về sau khi View đã destroy thì crash. Bạn sẽ còn gặp MVP trong codebase viết khoảng 2018–2021, nhưng màn hình mới không nên bắt đầu bằng MVP: ViewModel đã làm đúng việc Presenter làm, kèm lifecycle và scope coroutine miễn phí.

MVVM: View quan sát state, ViewModel giữ state

UI ──event──▶ ViewModel ──gọi──▶ Repository ──▶ Room / API
UI ◀──StateFlow (state bất biến)── ViewModel

ViewModel sống qua configuration change, nên xoay màn hình không mất state và không gọi lại API. Nhưng MVVM “cổ điển” vẫn có thể hai chiều: View gọi hàm, ViewModel callback qua observer. Với Compose, dạng đúng là state chảy xuống, event chảy lên — tức MVVM cộng thêm luồng một chiều. Đây là lựa chọn mặc định của Google và của gần như mọi app Kotlin mới.

MVI: mọi thay đổi là một Intent, mọi hiển thị là một State

UI ──Intent──▶ Reducer(state, intent) ──▶ State mới ──▶ UI
                    ▲
             Repository / Model

MVI gộp toàn bộ state màn hình vào một object bất biến và bắt mọi thay đổi đi qua một cửa: Intent. Hàm reduce() là pure function — cùng state cũ và cùng intent luôn ra cùng state mới — nên test không cần coroutine, không cần Android. Giá trị thật của MVI không phải chữ “MVI” mà là state transition có tên, có thể log và replay. Cái giá là nhiều kiểu dữ liệu hơn và dễ biến danh sách Intent thành một mê cung.

So sánh: được gì và trả giá gì

Pattern Điểm mạnh Cái giá
MVC Ít khái niệm, nhanh, hợp prototype vài màn hình Activity phình to, gần như không unit-test
MVP Presenter test được, logic tách khỏi UI Contract interface, attach/detach, boilerplate, vẫn hai chiều
MVVM Chuẩn Jetpack, lifecycle sẵn, test tốt, hợp Compose Dễ thành ViewModel khổng lồ; state phân mảnh khi thiếu kỷ luật
MVI State dự đoán được, reducer pure, debug tốt Nhiều kiểu, dễ nổ sealed class, chi phí cao

Lựa chọn thực dụng: MVVM + một chiều + repository

Với phần lớn màn hình Android, công thức đủ dùng là: UI → ViewModel → Repository → nguồn dữ liệu. ViewModel không giữ Context, không giữ View, không gọi Retrofit; nó nhận repository và SavedStateHandle qua constructor, expose state chỉ đọc và effect một lần. Repository là nơi duy nhất biết dữ liệu đến từ Room, network hay cache — cách dựng repository đã bàn kỹ ở bài Repository, Factory và Builder.

Ba quy tắc giữ cho mô hình không thoái hoá:

  • State là immutable. ViewModel sở hữu MutableStateFlow private, chỉ expose StateFlow qua asStateFlow(). UI không có setter.
  • Event không phải state. “Hiện toast”, “điều hướng sang màn khác”, “rung máy” là việc xảy ra một lần; nhét chúng vào UiState sẽ khiến chúng phát lại sau mỗi lần collect.
  • ViewModel không biết UI. Nó không import Composable, không giữ Activity, không đọc findViewById. Nhờ vậy unit test chạy trên JVM.

Ví dụ chạy được: ViewModel + StateFlow + Compose

Project dùng Kotlin 2.4.21, Compose BOM 2026.09.00, Hilt 2.60.1. Phần import được lược bớt cho gọn; code dưới chạy nguyên trạng khi bạn đã có ProfileRepository trả về model Profile.

// File: feature/profile/ProfileState.kt
sealed interface ProfileUiState {
    data object Loading : ProfileUiState
    data class Content(val name: String, val email: String) : ProfileUiState
    data class Error(val message: String) : ProfileUiState
}

// File: feature/profile/ProfileViewModel.kt
@HiltViewModel
class ProfileViewModel @Inject constructor(
    private val repository: ProfileRepository,
    savedState: SavedStateHandle,
) : ViewModel() {

    private val userId: String = checkNotNull(savedState["userId"])

    private val _state = MutableStateFlow<ProfileUiState>(ProfileUiState.Loading)
    val state: StateFlow<ProfileUiState> = _state.asStateFlow()

    private val _messages = Channel<String>(Channel.BUFFERED)
    val messages: Flow<String> = _messages.receiveAsFlow()

    private var loadJob: Job? = null

    init { load() }

    fun onRefresh() = load()

    private fun load() {
        loadJob?.cancel()
        _state.value = ProfileUiState.Loading
        loadJob = viewModelScope.launch {
            _state.value = try {
                val profile = repository.profile(userId)
                ProfileUiState.Content(profile.name, profile.email)
            } catch (_: IOException) {
                _messages.send("Không tải được hồ sơ")
                ProfileUiState.Error("Kiểm tra kết nối rồi thử lại")
            }
        }
    }
}
// File: feature/profile/ProfileScreen.kt
@Composable
fun ProfileScreen(
    viewModel: ProfileViewModel = hiltViewModel(),
    onMessage: (String) -> Unit,
) {
    val state by viewModel.state.collectAsStateWithLifecycle()

    LaunchedEffect(viewModel) {
        viewModel.messages.collect { text -> onMessage(text) }
    }

    when (val current = state) {
        ProfileUiState.Loading -> CircularProgressIndicator()
        is ProfileUiState.Content -> Column {
            Text(current.name)
            Text(current.email)
            Button(onClick = viewModel::onRefresh) { Text("Làm mới") }
        }
        is ProfileUiState.Error -> Column {
            Text(current.message)
            Button(onClick = viewModel::onRefresh) { Text("Thử lại") }
        }
    }
}

loadJob bị cancel trước mỗi lần load, nên bấm “Thử lại” liên tục không tạo hai request chồng nhau. Effect đi qua Channel + receiveAsFlow(): mỗi message được giao đúng một lần, không replay khi màn hình vào lại foreground. Nếu repository trả Flow (Room hoặc DataStore), đừng collect thẳng trong composable — dùng stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), initial) để biến cold flow thành state có lifecycle. Bài LiveData, Flow và lập trình phản ứng đi sâu vào phần này.

MVI: khi state chuyển tiếp thật sự phức tạp

MVI đáng dùng khi thứ tự chuyển tiếp quan trọng: thanh toán nhiều bước, form wizard, đồng bộ offline có retry, undo/redo. Khi đó, state chỉ đổi qua một danh sách Intent hữu hạn là lợi ích thật, không phải nghi thức.

// File: checkout/CheckoutReducer.kt
sealed interface CheckoutIntent {
    data class ApplyCoupon(val code: String) : CheckoutIntent
    data class CouponChecked(val percent: Int) : CheckoutIntent
    data object Pay : CheckoutIntent
}

data class CheckoutState(
    val coupon: String = "",
    val discountPercent: Int = 0,
    val phase: Phase = Phase.Idle,
    val error: String? = null,
) {
    enum class Phase { Idle, Checking, Ready, Paying, Done }
}

fun reduce(state: CheckoutState, intent: CheckoutIntent): CheckoutState = when (intent) {
    is CheckoutIntent.ApplyCoupon ->
        state.copy(coupon = intent.code, phase = CheckoutState.Phase.Checking, error = null)
    is CheckoutIntent.CouponChecked ->
        state.copy(discountPercent = intent.percent, phase = CheckoutState.Phase.Ready)
    CheckoutIntent.Pay -> state.copy(phase = CheckoutState.Phase.Paying)
}

Reducer là pure function, không suspend, không gọi repository. Phần bất đồng bộ nằm ngoài: ViewModel nhận ApplyCoupon, gọi API kiểm tra mã, rồi bắn CouponChecked hoặc intent lỗi trở lại reducer. Nhờ vậy luật chuyển trạng thái test bằng bảng input/output, không cần fake dispatcher. Effect một lần vẫn đi qua Channel; đừng trộn navigation hay toast vào state.

Năm bẫy thường gặp

  • ViewModel mang dependency Android. Giữ Context, Activity, Resources trong ViewModel làm unit test phải chạy Robolectric và dễ leak. Chỉ truyền repository, SavedStateHandle; nếu cần string thì trả resource id hoặc map ở lớp UI.
  • Business logic nằm trong composable. Tính tổng tiền, lọc danh sách, quyết định trạng thái trong @Composable khiến UI không test được và recomposition sai. Đưa phép tính vào ViewModel hoặc use case; composable chỉ render.
  • Expose mutable state. Trả MutableStateFlow ra ngoài cho phép UI sửa state trực tiếp, phá vỡ một chiều. Luôn asStateFlow() và giữ setter private.
  • Sealed state bùng nổ. Mỗi field mới lại thêm một nhánh Content(...) khiến when phình theo cấp số nhân. Nếu các field độc lập, dùng data class lồng bên trong một nhánh Content.
  • Trừu tượng hoá app nhỏ. Ba module, năm interface và reducer cho một màn hình đọc JSON là chi phí không ai hoàn lại. App dưới ~10 màn hình: một module + MVVM + repository là đủ.

Kiểm thử: nơi kiến trúc trả lại tiền

Với MVVM + một chiều, test unit không cần thiết bị: khởi tạo ViewModel với fake repository, gọi onRefresh(), assert state cuối. Vì viewModelScope chạy trên Dispatchers.Main, hãy set Dispatchers.setMain(StandardTestDispatcher()) trong rule JUnit trước khi test — thiếu bước này test sẽ treo. Với MVI, test reducer còn rẻ hơn: một bảng (state, intent) → state mong đợi, không coroutine. UI test chỉ nên kiểm tra dây nối: state đúng thì composable hiển thị đúng, bấm thì gọi đúng hàm ViewModel.

Modularization: khi nào thật sự tách

Tách module không làm kiến trúc tốt hơn; nó chỉ làm ranh giới rõ hơn. Tách khi có một trong ba tín hiệu: build chậm đến mức ảnh hưởng vòng lặp phát triển, nhiều nhóm cùng sửa một module và hay conflict, hoặc một cụm tính năng được tái sử dụng ở app khác. Cách tách bền vững là theo feature (:feature:profile, :feature:checkout) cộng với :core:designsystem, :core:data, :core:domain. Đừng tách theo lớp ngay từ ngày đầu: ba module với ba file mỗi module chỉ tạo ma sát. Với Navigation 3, giữ NavKey ở module trung lập để feature không phải phụ thuộc lẫn nhau.

Nhìn về 2027

Kotlin 2.5.0 dự kiến ra mắt tháng 12/2026 và lifecycle 2.11.0 đã hỗ trợ KMP, nên logic dùng chung có thể đẩy lên lớp shared. Nếu cân nhắc Compose Multiplatform 1.12.2 cho UI, hãy giữ ViewModel và state machine ở phần dùng chung, để lựa chọn pattern không bị khoá vào Android. Điều không đổi: state một chiều và repository vẫn là nền.

Checklist trước khi chốt kiến trúc

  • Vẽ ba lớp UI / domain / data và chỉ ra ai sở hữu state trên từng màn hình.
  • Chọn UiState đúng dạng: sealed interface cho trạng thái loại trừ, data class cho state song song.
  • Kiểm tra ViewModel không import Android UI, không giữ Context, không expose MutableStateFlow.
  • Đặt effect một lần vào Channel hoặc SharedFlow, không nhét vào state.
  • Viết một unit test cho luồng lỗi và một test cho retry trước khi thêm màn hình tiếp theo.

Để đi tiếp trong series, bài Dependency Injection: Hilt, Koin và Dagger giải thích cách nối repository vào ViewModel bằng Hilt, còn lộ trình Android tổng thể cho bạn thấy kiến trúc nằm ở đâu trong toàn bộ các chặng.