Mobil Mimari Desenleri: MVVM, MVI ve Clean Architecture Katmanlarının Test Edilebilirlik Kıyaslaması
Bölüm 1: Bu Nedir ve Neden Hayati Önem Taşır?
Hayatınızı kolaylaştıran o akıllı ev uygulamasını açtığınızda, ışıkları açıp termostatı ayarlayan butonların arkasında ne olduğunu hiç düşündünüz mü? İşte mimari desenler, bu “perde arkası” düzeninin iskeletidir. MVVM (Model-View-ViewModel), MVI (Model-View-Intent) ve Clean Architecture; kodunuzun bir “spagetti tabağı” mı yoksa iyi organize bir “kütüphane” mi olacağını belirler. Neden bu kadar önemli? Çünkü bir uygulama hayata geçtiğinde asıl maliyet yazmakta değil, yıllar sonra bir hata düzeltirken veya yeni bir özellik eklerken “şu butonu koyunca diğer sayfa niye çöktü?” diye sürtünmede yatar. Doğru mimari, kodunuzu test edilebilir, değiştirilebilir ve anlaşıılır kılar. Yani geliştirici gece gündüz hata avcılığı yapmak yerine, yeni özellikler üreterek değer katar. Kısaca: Mimari, yazılımın “sağlık sigortası”dır; yoksa her küçük değişiklik kalp krizi riski taşır.
Bölüm 2: Perde Arkası: Sistem Nasıl Çalışıyor?
Düşünün ki uygulamanız bir restorandır. MVVM‘de garson (View) ile mutfak (Model) arasında bir “şef asistanı” (ViewModel) vardır. Garson siparişi alır, asistan mutfakla konuşur, yemek hazır olunca garsona “hazır, götür” der. Veri akışı çift yönlüdür, bağlama (binding) sayesinde arayüz otomatik güncellenir. MVI ise daha sıkı bir disiplindir: Her şey bir “Niyet” (Intent) ile başlar. Kullanıcı butona basar -> Sistem bu niyeti işler -> Yeni bir “Durum” (State) üretir -> Arayüz bu durumu yansıtır. Veri tek yönlü akar, geriye dönüş yoktur. Clean Architecture ise restoranın katlarıdır: En içte “İş Kuralları” (Entities/Use Cases), dışarıya doğru “Arayüzler” (Controllers/Gateways) ve en dışta “Araçlar” (DB, Network, UI) vardır. İç katmanlar dış katmanlardan habersizdir; bağımlılık okları her zaman içe doğru bakar. Bu sayede veritabanını değiştirmek arayüzü bozmaz.
Bölüm 3: Bilim Dünyası ve Uzmanlar Nasıl İnceliyor?
Akademik dünyada ve endüstri liderlerinde (Google, JetBrains, Square mühendisleri) bu desenler “doğru mu yanlış mı” değil, “hangisi hangi sorunu çözer” ekseninde tartışılır. Google’ın resmi rehberleri artık MVI’ye yakın bir yapıyı (UDF – Unidirectional Data Flow) ve Clean Architecture’ı birleştirerek öneriyor. Neden? Çünkü büyük ekiplerde “State” (durum) yönetimi en büyük baş ağrısıdır. MVVM’de LiveData veya StateFlow ile iki yönlü bağlama kolay başlar ama proje büyüdüğünde “Kim bu veriyi değiştirdi?” sorusunun cevabını bulmak imkansızlaşır. MVI ise her değişikliği bir “Event/Intent” loglamasıyla izlenebilir kılar. Test edilebilirlik açısından bakıldığında; Clean Architecture’ın Use Case (Interactor) katmanı, iş mantığını Android/ios framework’lerinden tamamen ayırır. Bu da “Unit Test” yazmayı bir efsanevi mücadeleden, sıradan bir fonksiyon çağrısına indirger. Uzmanların ortak lafı: “Mimari, ekip büyüklüğü ve proje ömrüne göre seçilir; evrensel mükemmel yoktur.”
Bölüm 4: Önemli Parametreler ve Karşılaştırma Rehberi
| Parametre | MVVM (Model-View-ViewModel) | MVI (Model-View-Intent) | Clean Architecture (Katmanlı) |
|---|---|---|---|
| Veri Akış Yönü | Çift yönlü (Two-way Binding) | Tek yönlü (Unidirectional) | Katmanlara göre değişir (Genelde Use Case -> Presenter) |
| Durum (State) Yönetimi | Dağınık, ViewModel içinde birden fazla LiveData/StateFlow |
Merkezi, tek bir State nesnesi (Immutable) |
Use Case çıktısı olarak merkezi durum üretilir |
| Test Edilebilirlik (Unit Test) | Orta (ViewModel test edilir, Binding test zordur) | Çok Yüksek (Pure functions: Intent -> State) | Çok Yüksek (Use Case’ler framework’lerden bağımsızdır) |
| Bağımlılık Yönü | View -> ViewModel -> Model | View -> Intent -> Reducer -> State | Dış Katman -> İç Katman (Dependency Inversion) |
| Öğrenme Eğrisi | Düşük (Başlangıç için ideal) | Orta/Yüksek (Reactive thinking gerektirir) | Yüksek (SOLID, DI, Modülerlik bilgisi ister) |
| Hata Ayıklama (Debugging) | Zor (Kim state’i değiştirdi?) | Kolay (Log: Intent -> State geçişleri) | Orta (Katmanlar arası mocklama gerekebilir) |
| Boilerplate (Şablon Kod) | Az | Orta/Yüksek (Action/State/Reducer sınıfları) | Çok Yüksek (Interface/Impl/Mapper/DI modülleri) |
| Yeniden Kullanılabilirlik | Orta (ViewModel UI’ya bağlı kalabilir) | Yüksek (State/Logic UI’dan tamamen ayrı) | En Yüksek (Use Case’ler platformdan bağımsızdır) |
| İdeal Kullanım Alanı | Küçük/Orta projeler, hızlı prototip, küçük ekipler | Büyük ekipler, karmaşık state’li ekranlar, uzun ömürlü ürünler | Enterprise uygulamaları, çok platformlu (KMP) projeler, yüksek kalite standartları |
| Kotlin Multiplatform (KMP) Uyumu | İyi (ViewModel paylaşılabilir) | Mükemmel (Pure Kotlin State/Logic paylaşılır) | Mükemmel (Domain/Data katmanları tamamen paylaşılır) |
| Migration (Göç) Kolaylığı | Kolay (Legacy’den gelince) | Zor (Mental model değişimi ister) | Nokta atışı modüllerle yapılır, Big Bang riski düşürülür |
Bölüm 5: Günlük Hayatta ve Doğada Nerede Karşımıza Çıkar?
Bir e-ticaretdaki “Sepete Ekle” butonuna basdığınızı düşünün. MVVM‘de buton tıklama -> ViewModel’e komut -> Repository’den API çağrısı -> Başarılı olunca sepetSayisi LiveData’sı güncellenir -> Badge animasyonu çalışır. Basit ama; kullanıcı hızlıca iki kez basarsa? İki istek gider, race condition olur, badge 2 artar ama sunucuda 1 olur. MVI‘de: AddToCartIntent -> Reducer loading: true state’i üretir -> UI spinner gösterir -> API cevabı -> Reducer success: true, count: 5 state’i üretir -> UI güncellenir. Kullanıcı ikinci basışta loading doluysa Intent işlenmez veya kuyruğa alınır. Doğadaki benzetme: MVVM bir radyo frekansına ayarlamak gibidir (parazit olabilir). MVI ise bir blok zinciri (blockchain) gibidir; her işlem (blok) onaylanmadan yenisine geçilmez, geçmiş silinmez. Clean Architecture ise vücudunuzdur; mideniz (Domain) ne yerseniz sindirir, cildiniz (UI) yanarsa mideniz etkilenmez, sadece cilt onarılır.
Bölüm 6: Karşılaşılan Zorluklar ve Pratik Çözümler
En büyük tuzak: “Clean Architecture yapıyorum” diyerek her sınıf için Interface yazıp, tek bir Implementasyon yapıp, 50 dosya açmak. Bu “Over-engineering” (Aşırı mühendislik)dir. Çözüm: Başlangıpta Use Case yazmayın, ViewModel doğrudan Repository konuşsun. İhtiyaç olunca (örneğin aynı mantığı widget’ta da kullanacaksınız) Use Case çıkarın. MVI’deki “Boilerplate” (Şablon kod) sıkıntısı: Her ekran için Action, State, Reducer yazmak yorucudur. Çözüm: BaseMviViewModel veya MviScreen gibi soyut bir baz sınıf/kütüphane (Orbit, MvRx, Decompose) kullanın. Test yazmama alibisi: “MockK/Mockito kurmak zor” diyip test yazmamak. Çözüm: Clean Architecture’da Use Case’ler suspend fun execute(): Result imzalı saf Kotlin fonksiyonlarıdır. Onları test etmek için hiçbir kütüphaneye ihtiyacınız yoktur, sadece assertEquals yeterlidir. Son olarak: Mimari dini değil, araçtır. “Bu ekran 2 hafta ölecek bir kampanya ekranı” dese, Clean Architecture kurmak günahdır; MVVM ile bitirip geçin.
Bölüm 7: Gelecek Perspektifi ve Yeni Gelişmeler
Gelecek Kotlin Multiplatform (KMP) ve Compose Multiplatform‘ın rengindedir. Artık “Android mimarisi” yok, “Paylaşılan Kotlin Mimarisi” var. Google’ın yeni rehberleri (Now in Android, Compose Samples) neredeyse tamamen MVI + Clean Architecture hibridini benimsedi. Neden? Çünkü Compose’un State mekanizması MVI’nin Immutable State felsefesiyle birebir örtüşüyor. collectAsStateWithLifecycle() ile UI, State’i sadece izliyor. Yeni trend: Server-Driven UI (SDUI). Sunucu JSON olarak “Bu ekran şu butonları, şu listeyi göster” diyor, uygulama yorumluyor. Bu da Use Case’lerinizin “Sunucudan şema al -> UI modeline çevir” olmasını gerektiriyor; yani Domain katmanınızın gücü artıyor. Ayrıca KSP (Kotlin Symbol Processing) ile Dagger/Hilt yerine Koin Annotations veya Dagger KSP, build hızını katlıyor. Gelecekte “Mimari kurmak” demek, “Gradle modül grafiğini doğru kurmak” demek olacak.
Bölüm 8: Merak Edilen Sorular ve Cevaplar (SSS)
Soru 1: Hangi mimariyi seçmeliyim? Benim için en iyisi hangisi?
Cevap: “En iyisi” yok, “ihtiyacınıza uyan” var. 2-3 kişilik ekip, 3-4 ayda bitecek proje, karmaşık state yoksa MVVM en pratiklisidir. 10+ kişilik ekip, yıl yıl gidecek proje, offline-first, karmaşık formlar/akışlar varsa MVI + Clean Architecture sizi kurtarır. Başlangıçta basit tutun, acı çekince katman ekleyin.
Soru 2: MVI’de o kadar çok sınıf (Action, State, Reducer) açmak kod karmaşasına yol açmıyor mu?
Cevap: Açar, evet. Ama bu “iyi bir karmaşadır”. Her şeyin yerli yerinde olduğunu bilirsiniz. Orbit-MVI, MvRx veya Decompose gibi kütüphaneler bu şablon kodun %80’ini alır. Kendi BaseMviViewModel yazarsanız da yeni ekran açmak 5 dakikanızı alır. Karmaşa, dosya sayısında değil, “kim neyi değiştirdi” belli olmamasında olur.
Soru 3: Clean Architecture yapmadan MVI yapabilir miyim?
Cevap: Evet, yapabilirsiniz. ViewModel içinde Reducer tutarsınız, Repository’yi doğrudan çağırırsınız. Bu “Temiz MVI”dir. Ama test yazarken Repository’yi mocklamak zorlaşır (ViewModel testinde network katmanı sızar). Clean Architecture’ın gücü, Use Case’i test ederken hiçbir Android sınıfına ihtiyaç duymamaktır.
Soru 4: MVVM’de LiveData mı StateFlow mu kullanmalıyım?
Cevap: Yeni projelerde kesinlikle StateFlow / SharedFlow. Coroutines ile entegrasyonu mükemmeldir, combine, flatMapLatest gibi operatörlerle veri akışını yönetmek çocuk oyuncağıdır. LiveData lifecycle-aware olduğu için eski destek için dursun, modern Compose/Kotlin dünyasında Flow kraldır.
Soru 5: Test yazmak için MockK mı Mockito mi?
Cevap: MockK. Kotlin için yazıldı, coEvery, coVerify, relaxed = true sözdizimi Kotlin’in suspend fonksiyonları, data classlar ve object singleton’larıyla tam uyumludur. Mockito Kotlin’de bazen suspend fonksiyonlarda “coroutine context” hataları verip canınızı sıkabilir.
Soru 6: KMP (Kotlin Multiplatform) projelerde hangi mimari şart?
Cevap: Clean Architecture + MVI (veya UDF) neredeyse zorunludur. Çünkü expect/actual mekanizması ile Platform (Android/iOS/Desktop) spesifik kodları (UI, Database driver, Network client) soyutlamanız (Interface) ve Domain/Data katmanlarını commonMain içinde paylaşmanız gerekir. MVVM’in ViewModel paylaşımı mümkün ama MVI’nin State/Reducer paylaşımı çok daha doğal ve güvenlidir.
Bölüm 9: Bilmeniz Gereken Temel Terimler
Durum (State) – (Ekranın O Anki “Fotoğrafı”): Uygulamanın o anki tüm verisinin (liste, loading, hata, kullanıcı girişi) tek bir nesne içinde toplanmış halidir. MVI’de bu nesne data classdır ve değiştirilemez (immutable). Değişiklik yapmak için eskisi kopyalanır, yenisi üretilir. Böylece “eski durum neydi, yeni durum ne?” karşılaştırması çocuk oyuncağı olur.
Niyet (Intent) – (Kullanıcının “Dileği”): Kullanıcının veya sistemin “bir şeyler olsun” isteğidir. Butona basma, ekranı yenileme, veri gelme. MVI’de her şey bir Intent (veya Action) ile başlar. Bu sayede “Kullanıcı ne yaptı?” sorusunun cevabı loglarda tek satırda görünür.
Kullanım Durumu (Use Case / Interactor) – (İş Mantığının “Beyini”): Clean Architecture’ın kalbidir. “Kullanıcı girişi yap”, “Sepeti getir”, “Ödeme yap” gibi tek bir iş kuralını içeren sınıflardır. Android/ios bilmezler, sadece suspend fun execute(): Result derler. Onları test etmek, bir hesap makinesi test etmek kadar kolaydır.
Bağımlılık Ters Çevirme (Dependency Inversion) – (Siparişin Tersine Dönmesi): İç katman (Domain), dış katmana (Data/UI) “Benim istediğim arayüz (Interface) şu, sen onu uygula” der. Dış katman iç katmana bağımlı olur, iç katman dıştan habersiz kalır. Böylece veritabanını SQLite’dan Room’a, Room’dan Realm’e değiştirirken iş kurallarınızı (Use Case) hiç dokunmazsınız.
Tek Yönlü Veri Akışı (Unidirectional Data Flow – UDF) – (Tek Şeritli Yol): Verinin her zaman aynı yönde (Intent -> State -> View) aktığı sistem. Geri dönüş yok, yan şerit yok. Bu, “Bu değişkeni kim değiştirdi?” kabusunu sona erdiren sihirli değnekten başkası değildir.
Boilerplate (Şablon Kod / Hazır Şablon) – (Sıkıcı Kağıt İşleri): Her yeni özellikte kopyalayıp yapıştırdığınız, mantık taşımayan, sadece yapıyı ayağa kaldıran kodlardır. MVI ve Clean Architecture başlangıçta bunu artırır, ama uzun vadede “Nereye yazayım?” kafa karışıklığını önler. Kütüphanelerle (KSP, Orbit, Decompose) minimize edilir.
Bölüm 10: Özet ve Çıkarılması Gereken Dersler
Mimari desenler, kodunuzu “yazılabilir” kılmak için değil, “okunabilir, test edilebilir ve değiştirilebilir” kılmak için vardır. MVVM, hızı ve basiti seven küçük ekiplerin güvenli limanıdır. MVI, karmaşık state’lerin efendisi, hata ayıklamanın kolaylığı ve takip edilebilirliğin kralıdır. Clean Architecture ise projenizin ömrünü uzatan, platformdan (Android/iOS/Web) bağımsızlaştıran, testleri “saniyelerde bitiren” stratejik yatırımdır. Altın Kural: Mimariyi projenin boyutuna ve ekibinizin deneyimine göre seçin, “Moda olduğu için Clean Architecture kurup” 50 boş Interface ile projenizi boğmayın. Başlayın, acı çekin (test yazarken, mocklarken, modül eklerken), o zaman doğru katmanı ekleyin. En iyi mimari, size gece uyku getiren, sabah “Bu özelliği nereye koyalım?” diye düşünmektense “Hadi yazalım” diyen mimaridir. Test edilebilir kod yazmak bir lüks değil, profesyonelliğinizin kanıtıdır.