Repository, Factory, Builder là ba cái tên ai cũng ghi được trong CV, nhưng phần lớn codebase dùng chúng như nghi thức: thêm một interface, thêm một lớp, thêm một factory, rồi không ai giải thích được lớp đó giải quyết vấn đề gì. Năm 2026, với Kotlin 2.4.21, Compose và Hilt, một nửa các mẫu thiết kế trong sách Java đã thành mặc định của framework hoặc không còn cần thiết.
Mục lục
Cập nhật 2026
- Kotlin 2.4.21: named argument, default value và
copy()khiến Builder kiểu Java gần như dư thừa với object thuần Kotlin. - Room 2.8.5 và Hilt 2.60.1 dùng KSP2; KAPT là legacy, không cấu hình cho dự án mới.
- Hilt sinh factory thay bạn. Viết tay
ViewModelProvider.Factorychỉ còn ý nghĩa khi tham số đến từ runtime hoặc bạn không dùng DI. - Compose-first: màn hình mới không còn
RecyclerView.Adapter; Adapter pattern rút về một hàm map dữ liệu và một lambdacontent.
Mẫu thiết kế trong Android 2026: giữ gì, bỏ gì
Mẫu thiết kế là câu trả lời cho một vấn đề cụ thể. Ba mẫu dưới đây vẫn sống vì vấn đề của chúng vẫn tồn tại: dữ liệu từ nhiều nguồn, biến thể chọn lúc chạy, cấu hình có ràng buộc chéo.
Repository: một nguồn sự thật duy nhất
Repository không phải “lớp bọc API”. Nó là nơi duy nhất quyết định dữ liệu thật nằm ở đâu. Trong mô hình đúng, UI không bao giờ quan sát network: network ghi vào Room, UI quan sát Room. Room là single source of truth, mạng chỉ là cách làm mới nó.
Ba hành vi cho thấy bạn làm đúng: mất mạng vẫn có dữ liệu cũ, hai màn hình thấy cùng một state, refresh lỗi không làm trắng danh sách.
Bắt đầu bằng kiểu lỗi. Dùng sealed interface thay vì ném exception, vì UI phải render được trạng thái lỗi, còn lỗi mạng là chuyện bình thường.
// File: data/article/Result.kt
sealed interface Result<out T> {
data class Success<T>(val data: T) : Result<T>
data class Failure(val error: AppError) : Result<Nothing>
}
sealed interface AppError {
data object Offline : AppError
data object NotFound : AppError
data object Unsupported : AppError
data class Unexpected(val cause: Throwable) : AppError
}
// File: data/article/ArticleDao.kt
@Entity(tableName = "articles")
data class ArticleEntity(
@PrimaryKey val id: String,
val title: String,
val body: String,
)
@Dao
interface ArticleDao {
@Query("SELECT * FROM articles ORDER BY title")
fun observeAll(): Flow<List<ArticleEntity>>
@Upsert
suspend fun upsertAll(items: List<ArticleEntity>)
}
// File: data/article/ArticleApi.kt
interface ArticleApi {
@GET("articles")
suspend fun articles(): List<ArticleDto>
}
// File: domain/Article.kt
data class Article(val id: String, val title: String, val body: String)
Giờ là phần quyết định: interface cho tầng trên, implement giữ cả hai nguồn, và chuyển lỗi Retrofit thành kiểu lỗi của app.
// File: data/article/ArticleRepository.kt
interface ArticleRepository {
fun observeArticles(): Flow<List<Article>>
suspend fun refresh(): Result<Unit>
}
class DefaultArticleRepository @Inject constructor(
private val dao: ArticleDao,
private val api: ArticleApi,
) : ArticleRepository {
override fun observeArticles(): Flow<List<Article>> =
dao.observeAll()
.map { rows -> rows.map(ArticleEntity::toDomain) }
.distinctUntilChanged()
override suspend fun refresh(): Result<Unit> = withContext(Dispatchers.IO) {
try {
dao.upsertAll(api.articles().map(ArticleDto::toEntity))
Result.Success(Unit)
} catch (e: IOException) { // mất mạng, timeout, DNS
Result.Failure(AppError.Offline)
} catch (e: HttpException) { // 4xx, 5xx
Result.Failure(AppError.NotFound)
} catch (e: Exception) {
Result.Failure(AppError.Unexpected(e))
}
}
}
ViewModel chỉ thấy interface, nên nó không biết gì về Room, Retrofit hay thứ tự cache. Hilt nối interface với implement bằng một @Binds trong module @InstallIn(SingletonComponent::class); không cần lớp trung gian nào khác.
// File: ui/article/ArticleListViewModel.kt
@HiltViewModel
class ArticleListViewModel @Inject constructor(
private val repository: ArticleRepository,
) : ViewModel() {
val articles: StateFlow<List<Article>> = repository.observeArticles()
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
private val _error = MutableSharedFlow<AppError>()
val error: SharedFlow<AppError> = _error.asSharedFlow()
fun refresh() = viewModelScope.launch {
val result = repository.refresh()
if (result is Result.Failure) _error.emit(result.error)
}
}
WhileSubscribed(5_000) giữ luồng sống 5 giây sau khi UI ngừng collect, đủ để xoay màn hình không phải query lại database.
Vì sao cần interface khi chỉ có một implement? Vì test. Một fake ArticleRepository trong src/test cho bạn chạy ViewModel trên JVM mà không cần Room, emulator hay mạng — đó là implementation thứ hai, dù nó chỉ sống trong test. Không có test nào swap được interface đó thì xóa interface, để Hilt inject thẳng class.
Repository cũng không phải god object: một repository cho một aggregate hoặc ranh giới feature, không phải AppRepository 40 hàm. Nó không chứa business rule (việc của use case), không format text cho UI, không giữ Context.
Factory: chọn biến thể lúc chạy
DI trả lời “ai cấp dependency”; Factory trả lời “tạo biến thể nào với tham số nào”. Trộn hai câu hỏi này là nguồn gốc của gần như mọi factory vô dụng trong codebase Android.
Factory còn giá trị ở ba chỗ: biến thể phụ thuộc dữ liệu runtime (phương thức thanh toán, nhà cung cấp auth, phiên bản OS), tạo object có validate và trả Result, và ViewModel cần tham số runtime. Thanh toán là ví dụ thật: cùng màn hình checkout, ba cách trả tiền, mỗi cách một SDK.
// File: payment/PaymentGatewayFactory.kt
interface PaymentGateway {
suspend fun pay(request: PaymentRequest): Result<Receipt>
}
enum class PaymentMethod { CARD, WALLET, COD }
class PaymentGatewayFactory @Inject constructor(
private val card: CardGateway,
private val wallet: WalletGateway,
) {
fun create(method: PaymentMethod): Result<PaymentGateway> = when (method) {
PaymentMethod.CARD -> Result.Success(card)
PaymentMethod.WALLET -> Result.Success(wallet)
PaymentMethod.COD -> Result.Failure(AppError.Unsupported)
}
}
Để ý hai điều: factory không dựng dependency, nó nhận qua constructor; và nhánh không hỗ trợ trả Result.Failure thay vì ném exception, nên UI buộc phải xử lý. Một factory tự gọi Retrofit.Builder() hay Room.databaseBuilder() bên trong là factory che DI, và bạn mất khả năng thay base URL trong test.
Với ViewModel, Hilt đã sinh factory. Bạn chỉ cần tự viết khi không dùng DI, và nó ngắn hơn bạn tưởng:
// Có Hilt: không factory nào được viết tay
@HiltViewModel
class ArticleListViewModel @Inject constructor(repo: ArticleRepository) : ViewModel()
// Không dùng DI: một factory khai báo một lần
val ArticleVmFactory = viewModelFactory {
initializer {
val app = this[APPLICATION_KEY] as NotesApp
ArticleListViewModel(app.container.articles)
}
}
Tham số runtime (id của draft đang mở, filter đã chọn) đi qua SavedStateHandle nếu đến từ navigation, hoặc qua Hilt assisted injection nếu không serialize được. Đừng dựng factory chỉ để truyền một Long mà SavedStateHandle đã chở sẵn.
Builder: Kotlin đã lấy mất việc của nó
Builder tồn tại vì hai lý do trong Java: constructor có quá nhiều tham số dễ truyền sai vị trí, và object bất biến không có cách “sửa một field”. Kotlin xử lý cả hai bằng cú pháp, không bằng lớp.
// Kiểu Java, 2010
new UserPreferences.Builder().setPush(false).setTheme("dark").build();
// Kotlin, 2026
UserPreferences(push = false, theme = Theme.Dark)
current.copy(push = true) // cập nhật một field, không cần builder
Vậy builder còn dùng khi nào? Khi field có ràng buộc chéo và cần validate lúc build; khi API phục vụ code Java; khi cấu hình lồng nhau mà DSL đọc dễ hơn object literal; khi là API public của thư viện, nơi thêm field không được phá signature. Ví dụ thật: lịch sync WorkManager, nơi interval tối thiểu 15 phút và constraint phải khớp nhau.
// File: sync/SyncSchedule.kt
@DslMarker
annotation class SyncDsl
data class SyncSchedule(
val wifiOnly: Boolean,
val intervalMinutes: Long,
val retries: Int,
val tags: List<String>,
)
@SyncDsl
class SyncScheduleBuilder internal constructor() {
var wifiOnly: Boolean = true
var intervalMinutes: Long = 15
var retries: Int = 3
private val tags = mutableListOf<String>()
fun tag(value: String) { tags += value }
fun build(): SyncSchedule {
require(intervalMinutes >= 15) { "WorkManager: periodic interval tối thiểu 15 phút" }
require(retries in 0..10) { "retries phải trong 0..10" }
if (wifiOnly) require(tags.isNotEmpty()) { "wifiOnly cần ít nhất một tag" }
return SyncSchedule(wifiOnly, intervalMinutes, retries, tags.toList())
}
}
fun syncSchedule(block: SyncScheduleBuilder.() -> Unit): SyncSchedule =
SyncScheduleBuilder().apply(block).build()
Cách dùng đọc như một câu, và lỗi cấu hình nổ ngay lúc tạo:
val schedule = syncSchedule {
intervalMinutes = 60
retries = 2
tag("articles")
}
val request = PeriodicWorkRequestBuilder<SyncWorker>(
schedule.intervalMinutes, TimeUnit.MINUTES,
).setConstraints(
Constraints.Builder()
.setRequiredNetworkType(if (schedule.wifiOnly) NetworkType.UNMETERED else NetworkType.CONNECTED)
.build(),
).build()
Bẫy: builder có state mutable. Dùng lại một builder cho hai object là tự tạo bug chia sẻ state; giữ builder trong singleton là biến nó thành biến toàn cục; build() mà có sửa state thì gọi hai lần ra hai kết quả khác nhau. Quy tắc: builder mới mỗi lần, build() chỉ đọc state và trả snapshot.
Năm mẫu bạn dùng hằng ngày mà không gọi tên
Observer là Flow/StateFlow. Repository phát flow, ViewModel stateIn, Compose collectAsStateWithLifecycle. Không cần tự viết observer, nhưng cần hiểu vòng đời subscription — đó là lý do WhileSubscribed tồn tại.
Adapter đổi hình dạng theo UI toolkit. Với RecyclerView, bạn viết ListAdapter cộng DiffUtil để bind dữ liệu vào ViewHolder. Với Compose, không có adapter class: LazyColumn nhận lambda content cho từng item, còn phần “adapt” thật sự là hàm map domain model sang UI model.
Singleton có hai dạng rất khác nhau. object của Kotlin là singleton cấp process: không inject được, không thay được trong test, và là chỗ dễ rò rỉ Context nhất. @Singleton của Hilt cũng giữ một instance, nhưng do graph quản lý và thay được bằng module test. Singleton cần Context thì chỉ nhận @ApplicationContext; giữ Activity trong đó là leak chắc chắn.
Strategy là cách thêm biến thể mà không thêm if. Ví dụ auth: interface TokenProvider với currentToken(), implement bằng Credential Manager hay Firebase, một fake trả token cố định trong test. Chọn biến thể ở một chỗ, không rải điều kiện khắp ViewModel.
Decorator là chuỗi wrapper. OkHttp Interceptor là decorator thật: auth header, retry, logging, mỗi cái bọc cái trước. Compose Modifier cũng vậy, và thứ tự trong chuỗi chính là ngữ nghĩa.
Anti-pattern: thờ mẫu thiết kế
Pattern worship là khi code được viết để chứng minh bạn biết mẫu, không phải để giải quyết vấn đề. Dấu hiệu: một interface cộng một implementation mà không test nào từng swap; một factory luôn trả về đúng một object; một builder cho class ba field; một lớp tên UserRepositoryManagerFactoryImpl mà không ai hiểu nó làm gì. Mỗi lớp thêm là một chỗ để hiểu sai, để viết test, để refactor — một hàm 30 dòng dễ sửa hơn ba lớp 10 dòng nối nhau bằng interface.
Quy tắc thực dụng: abstraction phải trả tiền cho chỗ nó chiếm. Nó có giá trị khi có implementation thứ hai thật (kể cả fake trong test), hoặc có ràng buộc runtime thật (biến thể chọn lúc chạy, validate, Java caller). Không có hai điều đó thì viết thẳng. Đừng bê Abstract Factory, private constructor cộng static getInstance(), hay getter/setter Java sang Kotlin — Kotlin có object, property, default argument.
Bảng quyết định
| Mẫu | Dùng khi | Bỏ qua khi |
|---|---|---|
| Repository | Có từ hai nguồn dữ liệu trở lên, cần cache và cần test không chạm mạng | Chỉ đọc một API, không cache, ViewModel gọi thẳng cũng ổn |
| Factory | Biến thể chọn bằng dữ liệu runtime, hoặc tạo object có validate | Tạo một object cố định — để DI làm |
| Builder / DSL | Ràng buộc chéo, cấu hình lồng nhau, Java interop | Object Kotlin thuần dưới 5 field — named argument là đủ |
| Singleton | Tài nguyên dùng chung thật: database, HTTP client, image cache | Chứa state của một màn hình — đó là việc của ViewModel |
| Strategy | Từ ba biến thể trở lên và mỗi biến thể có logic riêng | Hai nhánh đơn giản — một if rẻ hơn một interface |
Sáu bẫy và cách sửa
- Repository thành god object. Một class 40 hàm cho toàn app. Tách theo aggregate; business rule đưa sang use case.
- Abstraction cho một implementation. Giữ interface chỉ khi có fake hoặc impl thứ hai thật sự sẽ xuất hiện.
- Singleton giữ Context. Chỉ
@ApplicationContext; tốt hơn nữa là không giữ gì và nhận dependency qua constructor. - Builder có mutable state dùng lại. Builder mới mỗi lần,
build()trả snapshot, không lưu builder trong field. - Factory che DI. Factory chỉ chọn biến thể; việc dựng Retrofit, Room, OkHttp để Hilt làm.
- Tên mẫu không có nhu cầu. Đặt tên theo hành vi; nếu phải giải thích tên lớp bằng “vì đây là pattern X” thì đổi tên.
Nhìn về 2027
Kotlin 2.5.0 dự kiến ra mắt tháng 12/2026, và hướng đi rõ ràng là chia sẻ code qua Kotlin Multiplatform. Khi data layer nằm trong module shared, ranh giới repository càng quan trọng: shared chỉ phụ thuộc interface, implementation theo platform do DI cấp. Compose Multiplatform 1.12.2 đủ chín cho UI dùng chung, nên câu hỏi “mẫu này có cần không” sẽ thành “nó có sống được qua ranh giới platform không”.
Checklist
- Vẽ ra giấy nguồn dữ liệu nào là source of truth; nếu có hai, bạn cần repository.
- Chuyển lỗi mạng và lỗi parse thành một
sealed interface Resultdùng chung. - Viết fake repository trong
src/testtrước khi viết interface. - Rà factory: cái nào tự dựng dependency thì để Hilt dựng.
- Xóa builder cho object Kotlin thuần dưới 5 field, thay bằng named argument.
- Kiểm tra singleton: không giữ
Contextngoài application context.
Bài tiếp theo trong series
Đặt những mẫu này vào đúng kiến trúc: Lựa chọn kiến trúc cho ứng dụng Android: MVC, MVP, MVVM hay MVI. Nếu còn băn khoăn ai nên cấp dependency, đọc Dependency Injection trong Android: so sánh Hilt, Koin và Dagger. Phần cache trong bài dựa nhiều vào Room và DataStore, xem Lưu trữ dữ liệu trong Android: SharedPreferences, DataStore và Room. Mới vào series thì bắt đầu từ lộ trình học lập trình viên Android.



