
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
uygulamanın business logic (iş mantığı) kısmının uygulandığı yerdir; dolayısıyla burada use case (kullanım senaryosu),
service (servis), facade (ara katman) gibi yapılar tanımlanır. Bu katmanda coroutine scope (korotin kapsamı) nesneleri
üzerinde işlem yapmaktan ve doğrudan suspending function (askıya alınabilir fonksiyon) ifşa etmekten kaçınılmalıdır. Bu
iş, alt katmandaki presentation layer (sunum katmanı) tarafından yapılmalıdır; domain katmanında coroutine başlatmak
için coroutine scope fonksiyonları kullanılmalıdır.
suspend fonksiyonlar bulunur.// Bu sınıf, veri katmanında yer alan bir // repository implementasyonudur. Amacı, // dış servisten (API) kullanıcı verisi // çekmek ve bunu domain modeline dönüştürmektir. class NetworkUserRepository( private val api: UserApi, ) : UserRepository { // Bu metod, `UserApi` arayüzü ile // uzak sunucudan kullanıcı verisini çeker. // Elde edilen DTO (Data Transfer Object), // iş kurallarının uygulandığı domain modeline // dönüştürülerek döndürülür. override suspend fun getUser(): User = api.getUser().toDomainUser() } // Bu sınıf, haber içeriği sağlayan servis katmanıdır. // İçerisinde hem veri erişimi (`NewsRepository`) hem de // uygulama ayarları (`SettingsRepository`) kullanılır. // Amacı, haberleri işleyerek uygun formda sunmaktır. class NetworkNewsService( private val newsRepo: NewsRepository, private val settings: SettingsRepository, ) { // Tüm haberleri veri kaynağından çeker. // Çekilen veriler öncelikle DTO’dur. // Domain katmanında kullanılmak üzere // işlenerek `News` modeline dönüştürülür. suspend fun getNews(): List<News> = newsRepo .getNews() .map { it.toDomainNews() } // Bu fonksiyon, ayarlar üzerinden // özet haber türünü belirler. // Ardından bu türe göre uygun haberleri // veri kaynağından alarak döner. suspend fun getNewsSummary(): List<News> { val type = settings.getNewsSummaryType() return newsRepo.getNewsSummary(type) } }
coroutineScope ile sarmalı ve herişlemi başlatmak için içinde
async builder kullanmalıyız.// Bu fonksiyon, coroutineScope içinde eşzamanlı // işlemleri yöneterek bir kullanıcı üretir suspend fun produceCurrentUser(): User = coroutineScope { // Profil bilgisi ayrı bir coroutine içinde // eşzamanlı olarak başlatılır val profile = async { repo.getProfile() } // Arkadaş listesi verisi eşzamanlı olarak // ayrı bir coroutine ile alınır val friends = async { repo.getFriends() } // Her iki işlem tamamlandığında sonuçlar beklenir // ve kullanıcı nesnesi oluşturularak döndürülür User( profile.await(), friends.await() ) }
cancellation), istisna yönetimi (exception handling) veya bağlam aktarımı (context passing) gibi diğer tüm mekanizmalar
aynı şekilde kalmalıdır. Aşağıda verilen
produceCurrentUserSeq ve produceCurrentUserPar fonksiyonlarını dikkatealırsanız, aralarındaki tek önemli fark, ilkinin sıralı (sequential), ikincisinin ise iki paralel (parallel) işlemi
başlatmasıdır1Ayrıntılar için bkz. “Coroutine Kapsam Fonksiyonları ve Bağlam Mirası” bölümü..
// Bu fonksiyon kullanıcı verisini sıralı (ardışık) şekilde alır. // Her işlem, bir önceki tamamlandıktan sonra başlatılır. // Bu yöntem, bağımlı işlemler için uygundur ancak yavaştır. suspend fun produceCurrentUserSeq(): User { // Kullanıcı profili alınır. Bu işlem tamamlanmadan // sonraki adım başlatılamaz. IO beklemesi içerir. val profile = repo .getProfile() // Arkadaş listesi alınır. Profil verisi çekildikten sonra // bu işlem başlatılır. Yani işlemler sırayla ilerler. val friends = repo .getFriends() // Alınan profil ve arkadaş verileri kullanılarak // `User` domain nesnesi oluşturulur ve döndürülür. return User( profile, friends ) } // Bu fonksiyon kullanıcı verisini paralel (eşzamanlı) şekilde alır. // İki bağımsız işlem aynı anda başlatılır ve beklenir. // Bu yöntem, IO ağırlıklı bağımsız işlemler için idealdir. suspend fun produceCurrentUserPar(): User = coroutineScope { // Kullanıcı profili verisi `async` ile paralel başlatılır. // `async`, deferred sonuç üretir ve `await` ile alınır. val profile = async { repo.getProfile() } // Kullanıcının arkadaş verisi de aynı anda // paralel şekilde çekilir. Bağımsız işlemdir. val friends = async { repo.getFriends() } // Her iki `Deferred` nesnesi `await()` ile beklenir. // Bu sayede coroutine tamamlanana kadar askıya alınır. User( profile.await(), friends.await() ) }
async fonksiyonukullanarak ayrı coroutine başlatabiliriz; ancak aynı sonuca, yalnızca bir işlemi
async ile başlatıp diğerini aynıcoroutine içinde çalıştırarak da ulaşabiliriz. Aşağıdaki
produceCurrentUserPar fonksiyonu, öncekiyle neredeyse aynıdavranışı gösterecektir. Peki hangi yöntem tercih edilmelidir? Birçok geliştirici, paralel çalıştırılacak her işlem için
async kullanmanın kodun okunabilirliğini artırdığını savunarak ilk yöntemi tercih edecektir. Öte yandan bazıgeliştiriciler, daha az coroutine oluşturduğu ve daha az nesne yarattığı için ikinci yöntemin daha verimli olduğunu
savunabilir. Hangi seçeneği tercih edeceğiniz size kalmıştır.
// Bu fonksiyon, coroutineScope kullanarak paralel // veri çekme işlemlerini güvenli biçimde yürütür. suspend fun produceCurrentUserPar(): User = coroutineScope { // Profil bilgisi `async` ile eşzamanlı olarak başlatılır. // `Deferred` nesnesi döner, sonucu await ile alınır. val profile = async { repo.getProfile() } // Arkadaş listesi verisi de aynı şekilde paralel // olarak alınır. Profil ile bağımsız yürütülür. val friends = async { repo.getFriends() } // Her iki işlem tamamlanınca, `await` ile sonuçlar // alınır ve `User` domain nesnesi oluşturulur. User( profile.await(), friends.await() ) }
// Bu fonksiyon, verilen kullanıcı belirteciyle (token) // o kullanıcıya özel görüntülenebilir makaleleri döner. suspend fun getArticlesForUser( userToken: String?, ): List<ArticleJson> = coroutineScope { // Makaleler veri kaynağından `async` ile alınır. // Bu işlem paralel yürütülerek zaman kazandırır. val articles = async { articleRepository.getArticles() } // Kullanıcı bilgisi senkron biçimde alınır. // Bu işlem `suspend` ama paralel değildir. val user = userService .getUser(userToken) // Elde edilen makaleler beklenir, ardından filtrelenir. // Kullanıcının erişebileceği içerikler seçilir. articles.await() .filter { canSeeOnList(user, it) } // Filtrelenen her makale JSON biçimine dönüştürülür. .map { toArticleJson(it) } }
async fonksiyonu, koleksiyon işleme fonksiyonlarıyla birlikte kullanılarak her liste elemanı için asenkron bir işlembaşlatılabilir. Böyle durumlarda, sonuçları beklemek için
awaitAll fonksiyonunu kullanmak iyi bir uygulamadır.// Bu fonksiyon, verilen kategoriler için teklif // verilerini eşzamanlı (paralel) şekilde getirir. suspend fun getOffers( categories: List<Category> ): List<Offer> = coroutineScope { // Her kategori için ayrı bir `async` coroutine // başlatılır. Bu işlemler aynı anda çalışır. categories .map { async { api.requestOffers(it) } } // Tüm `Deferred<List<Offer>>` sonuçları beklenir. // `awaitAll`, hepsinin tamamlanmasını sağlar. .awaitAll() // Dönen sonuçlar `List<List<Offer>>` tipindedir. // `flatten` ile tek liste haline getirilir. .flatten() }
Örneğin, resilience4j kütüphanesi, askıya alınabilir fonksiyonlar için hız sınırlayıcılar sunar. Ayrıca listenizi
Flow'a dönüştürebilir ve ardından flatMapMerge kullanarak concurrency (eşzamanlılık) parametresiyle,göndereceğiniz eşzamanlı çağrı sayısını belirleyebilirsiniz2Ayrıntılar için bkz. “Akış (Flow) İşleme” bölümü, “flatMapConcat, flatMapMerge ve flatMapLatest” alt başlığı..
// Bu fonksiyon, verilen kategoriler için teklifleri // reaktif biçimde `Flow` olarak sunar. fun getOffers( categories: List<Category> ): Flow<List<Offer>> = // Kategori listesi, reaktif veri akışı olan // `Flow<Category>` biçimine dönüştürülür. categories .asFlow() // Her kategori için ayrı istek başlatılır. // `flatMapMerge`, maksimum 20 çağrı paralel yapar. .flatMapMerge( concurrency = 20 ) { // Her kategori için eşzamanlı API isteği yapılır. // Sonuçlar `Flow<List<Offer>>` olarak döner. suspend { api.requestOffers(it) }.asFlow() // Alternatif olarak şu da kullanılabilir: // flow { emit(api.requestOffers(it)) } }
mapAsync fonksiyonunu, concurrency (eşzamanlılık)parametresiyle tanımlayabilirsiniz.
// Bu fonksiyon, verilen kategoriler için teklifleri // eşzamanlı olarak alır ve tek liste döner. suspend fun getOffers( categories: List<Category> ): List<Offer> = categories // Her kategori için paralel istek başlatılır. // Sonuç olarak List<List<Offer>> elde edilir. .mapAsync { api.requestOffers(it) } // Liste içindeki listeler düzleştirilir. // Tüm teklifler tek bir listede toplanır. .flatten() // Bu extension fonksiyon, bir koleksiyondaki her öğeye // eşzamanlı `suspend` dönüşüm uygulamak için kullanılır. suspend fun <T, R> Iterable<T>.mapAsync( concurrency: Int = 20, // Maksimum paralel işlem sayısı // Dönüştürülecek işlem: her `T` için `R` üretir transformation: suspend (T) -> R ): List<R> = coroutineScope { // Paralel işlem sınırını korumak için `Semaphore` // kullanılır. Bu sayede fazla yük engellenir. val semaphore = Semaphore(concurrency) // Her öğe için bir coroutine başlatılır. // Her coroutine dönüşüm fonksiyonunu çalıştırır. this@mapAsync .map { async { // İşlem başlamadan önce semafor izin ister. // `withPermit` içinde dönüşüm güvenle yapılır. semaphore.withPermit { transformation(it) } } } // Tüm coroutine'lerin sonuçları beklenir. // Sonuçlar sıralı bir liste olarak döner. .awaitAll() }
coroutineScope kullanırken, herhangi bir çocuk coroutine (alt korotin) içindeki bir istisna, coroutineScopetarafından oluşturulan korotini bozacak, diğer tüm çocuklarını iptal edecek ve ardından bir istisna fırlatacaktır. Bu,
genellikle beklediğimiz davranıştır, ancak bazı durumlarda bizim için uygun olmayabilir. Bağımsız kabul edilen birden
fazla eşzamanlı işlem başlatmak istiyorsak, bunun yerine çocuklarındaki istisnaları göz ardı eden
supervisorScopekullanmalıyız3Ayrıntılar için bkz. “İstisna Yönetimi” bölümü, “supervisorScope” alt başlığı..
// Bu fonksiyon, kullanıcı aksiyonlarını analitik servisine // bildirir. Tüm işlemler paralel ve izole yürütülür. suspend fun notifyAnalytics( actions: List<UserAction> ) = supervisorScope { // `supervisorScope`, çocuk coroutine'leri birbirinden // bağımsız çalıştırır. Hata izolasyonu sağlar. actions.forEach { action -> // Her aksiyon için yeni bir coroutine başlatılır. // Bu yapı, yüksek eşzamanlılık sağlar. launch { // İlgili aksiyon analitik sistemine bildirilir. // Hata oluşsa bile diğer işlemler etkilenmez. notifyAnalytics(action) } } }
withTimeout veya withTimeoutOrNull kullanabiliriz4Ayrıntılar için bkz. “İptal Mekanizması (Cancellation)” bölümü, “withTimeout” alt başlığı.. Genellikle withTimeoutOrNull'u tercih ederim çünküwithTimeout, CancellationException (İptal İstisnası) fırlatır, bu da diğer istisnalardan farklı şekilde davranır.// Bu fonksiyon, kullanıcı verisini getirir. // Ancak işlem süresi 5 saniye ile sınırlandırılmıştır. suspend fun getUserOrNull(): User? = // `withTimeoutOrNull`, verilen süre içinde // işlem tamamlanmazsa `null` döner. withTimeoutOrNull( 5000 ) { // Kullanıcı verisi `fetchUser()` fonksiyonu // ile alınır. Bu işlem askıya alınabilir. fetchUser() }
fonksiyonları olan
map, filter veya onEach kullanırız, ve zaman zaman daha az yaygın fonksiyonlar olan scan veyaflatMapMerge gibi fonksiyonlar da kullanılır5Ayrıntılar için bkz. “Akış (Flow) İşleme” bölümü..// Bu sınıf, kullanıcı durumunu sağlayan katmandır. // Değişiklikleri sürekli olarak izleyen bir Flow üretir. class UserStateProvider( private val userRepository: UserRepository ) { // Kullanıcı durum akışı döner. Gözlemci bileşenler // bu akışı toplayarak canlı veri güncellemesi alır. fun userStateFlow(): Flow<User> = userRepository // Kullanıcıdaki değişiklikleri sürekli izleyen // bir Flow döner (`observeUserChanges`). .observeUserChanges() // Önemsiz değişiklikler filtrelenir. Sadece // işlevsel farklılıklar dikkate alınır. .filter { it.isSignificantChange } // Önceki kullanıcı verisi ile yeni güncelleme // `scan` operatörü ile birleştirilir. .scan( userRepository.currentUser() ) { user, update -> // Mevcut kullanıcıya gelen güncellemeler // uygulanarak yeni kullanıcı durumu üretilir. user.with(update) } // Birleştirilmiş sonuç, domain modeline dönüştürülür. // Arayüz ve iş mantığı katmanında bu nesne kullanılır
merge, zip veya combine gibi fonksiyonları kullanabilirsiniz6Ayrıntılar için bkz. “Akış (Flow) İşleme” bölümü, “merge, zip ve combine” alt başlığı..// Bu sınıf, iki farklı kaynakta bulunan makaleleri // birleştirip tek bir veri akışı olarak sunar. class ArticlesProvider( private val ktAcademy: KtAcademyRepository, private val kotlinBlog: KotlinBlogRepository, ) { // Her iki kaynakta da makale akışı vardır. // Bunlar dönüştürülüp tek bir `Flow` hâline gelir. fun observeArticles(): Flow<Article> = merge( // KtAcademy'den gelen makaleler alınır. // Her biri `Article` nesnesine çevrilir. ktAcademy .observeArticles() .map { it.toArticle() }, // KotlinBlog'dan gelen makaleler de alınır. // Aynı biçimde dönüştürülür ve birleştirilir. kotlinBlog .observeArticles() .map { it.toArticle() } ) } // Bu sınıf, kullanıcı durumu ve bildirimleri // birleştirerek bildirim durumunu üretir. class NotificationStatusProvider( private val userStateProvider: UserStateProvider, private val notificationsProvider: NotificationsProvider, private val statusFactory: NotificationStatusFactory, ) { // Bildirim akışı ve kullanıcı durumu birleşir. // Sonuç olarak `NotificationStatus` döner. fun notificationStatusFlow(): Flow<NotificationStatus> = // Tüm bildirimler gözlemlenir. Ancak sadece // görülmemiş olanlar işlenir. notificationsProvider .observeNotifications() .filter { it.status == Notification.UNSEEN } // Kullanıcı durumu ile birleştirilir. // Her değişiklikte yeni durum üretilir. .combine( userStateProvider.userStateFlow() ) { notifications, user -> // Bildirim ve kullanıcıya göre // `NotificationStatus` oluşturulur. statusFactory .produce(notifications, user) } }
SharedFlow'a dönüştürmelisiniz.Bunu yapmanın yaygın bir yolu,
shareIn fonksiyonunu bir scope (kapsam) ile kullanmaktır. Bu flow'u yalnızcagerektiğinde aktif tutmak için
started parametresi için WhileSubscribed seçeneğini kullanın7Ayrıntılar için bkz. “SharedFlow ve StateFlow” bölümü..// Bu sınıf, konum verisini sağlayan bir servis // katmanıdır. Akış (Flow) temelli çalışır. class LocationService( locationDao: LocationDao, // Veritabanı erişim arayüzü scope: CoroutineScope // Coroutine çalıştırma kapsamı ) { // Konum akışı paylaşılır. Bu sayede aynı veri // birden fazla gözlemciye gönderilir. private val locations = locationDao .observeLocations() // Akış, `shareIn` ile paylaşılır hale getirilir. // Tek bir kaynak üzerinden çoklu tüketim sağlanır. .shareIn( scope = scope, // Akış, yalnızca abone varsa aktiftir. // Terk edildiğinde otomatik durur. started = SharingStarted.WhileSubscribed() ) // Dış dünyaya konum akışı sunulur. // Her gözlemci bu akışı dinleyebilir. fun observeLocations(): Flow<List<Location>> = locations }
- 1.Ayrıntılar için bkz. “Coroutine Kapsam Fonksiyonları ve Bağlam Mirası” bölümü. ↩
- 2.Ayrıntılar için bkz. “Akış (Flow) İşleme” bölümü, “flatMapConcat, flatMapMerge ve flatMapLatest” alt başlığı. ↩
- 3.Ayrıntılar için bkz. “İstisna Yönetimi” bölümü, “supervisorScope” alt başlığı. ↩
- 4.Ayrıntılar için bkz. “İptal Mekanizması (Cancellation)” bölümü, “withTimeout” alt başlığı. ↩
- 5.Ayrıntılar için bkz. “Akış (Flow) İşleme” bölümü. ↩
- 6.Ayrıntılar için bkz. “Akış (Flow) İşleme” bölümü, “merge, zip ve combine” alt başlığı. ↩
- 7.Ayrıntılar için bkz. “SharedFlow ve StateFlow” bölümü. ↩