Sunum (Presentation/API/UI) Katmanı için Kotlin Coroutines Kullanım Senaryoları

Sunum (Presentation/API/UI) Katmanı için Kotlin Coroutines Kullanım Senaryoları

Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
Tartışmamız gereken son katman, genellikle coroutinelerin başlatıldığı Presentation layer (Sunum katmanı)'dır. Bazı
uygulama türlerinde, bu katman en kolay olanıdır çünkü Spring Boot veya Ktor gibi çerçeveler tüm işi bizim için yapar.
Örneğin, Spring Boot ile Webflux'ta, bir controller (denetleyici) fonksiyonunun önüne sadece suspend (askıya
alınabilir) modifikatörünü ekleyerek, Spring bu fonksiyonu bir coroutine içinde başlatır.
@Controller class UserController( private val tokenService: TokenService, // TokenService, kullanıcı kimlik doğrulaması için kullanılır private val userService: UserService, // UserService, kullanıcı verilerini yönetir ) { @GetMapping("/me") // "/me" endpoint'i, kullanıcının bilgilerini alır suspend fun findUser( @PathVariable userId: String, // URL yolundan kullanıcı ID'si alınır @RequestHeader("Authorization") authorization: String // Authorization başlığı alınır ): UserJson { val userId = tokenService.readUserId(authorization) // Token'dan kullanıcı ID'si okunur val user = userService.findUserById(userId) // Kullanıcı servisiyle kullanıcı bilgisi alınır return user.toJson() // Kullanıcı bilgisi JSON formatında döndürülür } }
Benzer destek, diğer kütüphaneler tarafından da sağlanır. Android'de, görevleri planlamak için Work Manager kullanırız.
CoroutineWorker sınıfını kullanabiliriz ve görevlerin ne yapması gerektiğini belirtmek için doWork metodunu
implement (uygulamak) ederiz. Bu metod bir suspend fonksiyondur, bu yüzden kütüphane tarafından bir coroutine içinde
başlatılır, bu nedenle bunu kendimiz yapmamıza gerek yoktur.
class CoroutineDownloadWorker( context: Context, // Context, uygulamanın durum bilgilerini sağlar params: WorkerParameters // WorkerParametreleri, işin başlatılması için gerekli parametreleri içerir ) : CoroutineWorker( context, params ) { // CoroutineWorker sınıfından türetilir, bu sınıf coroutines ile çalışır // `doWork` fonksiyonu, yapılacak işlemi tanımlar ve bir `suspend` fonksiyondur override suspend fun doWork(): Result { val data = downloadSynchronously() // Veriyi senkron şekilde indirir saveData(data) // İndirilen veriyi kaydeder return Result.success() // İş başarıyla tamamlandığında başarı sonucu döndürülür } }
Ancak, bazı durumlarda coroutin'leri kendimiz başlatmamız gerekir. Bunun için genellikle bir scope (kapsam)
nesnesi üzerinde launch kullanırız. Android'de, lifecycle-viewmodel-ktx sayesinde çoğu durumda viewModelScope veya
lifecycleScope kullanabiliriz.
class UserProfileViewModel( private val loadProfileUseCase: LoadProfileUseCase, // Profil verisini yüklemek için kullanılan işlev private val updateProfileUseCase: UpdateProfileUseCase, // Profil güncellemelerini işleyen işlev ) { private val _userProfile = MutableStateFlow<ProfileData?>(null) // Kullanıcı profili verisi val userProfile: StateFlow<ProfileData> = _userProfile // Kullanıcı profili akışı // ViewModel oluşturulduğunda çalışacak işlem fun onCreate() { viewModelScope.launch { // viewModelScope içinde coroutine başlatılır val userProfileData = loadProfileUseCase() // Profil verisi yüklenir _userProfile.value = userProfileData // Profil verisi StateFlow'a atanır // ... } } // Kullanıcı adının değiştiği durumda çalışacak işlem fun onNameChanged(newName: String) { viewModelScope.launch { // viewModelScope içinde coroutine başlatılır val newProfile = _userProfile.updateAndGet { // Kullanıcı profilini günceller it.copy(name = newName) // Yeni isimle profil verisini günceller } updateProfileUseCase(newProfile) // Güncellenen profil verisini kaydeder } } }

Creating custom scope (Özel kapsam oluşturma)

Eğer bir coroutine başlatabilen veya bir scope (kapsam) oluşturabilen bir kütüphane veya sınıfınız yoksa, bir
özel scope oluşturmanız ve bunu kullanarak bir coroutine başlatmanız gerekebilir.
class NotificationsSender( private val client: NotificationsClient, // Bildirimleri gönderen istemci private val notificationScope: CoroutineScope, // Kullanılacak özel coroutine kapsamı ) { // Bildirimleri göndermek için coroutine başlatılır fun sendNotifications(notifications: List<Notification>) { for (notification in notifications) { notificationScope.launch { // Her bildirim için yeni bir coroutine başlatılır client.send(notification) // Bildirim gönderilir } } } }
class LatestNewsViewModel( private val newsRepository: NewsRepository, // Haber verilerini sağlayan repository ) : BaseViewModel() { // BaseViewModel sınıfından türetilir private val _uiState = MutableStateFlow<NewsState>(LoadingNews) // UI durumu için StateFlow oluşturulur val uiState: StateFlow<NewsState> = _uiState // UI durumunu gözlemlemek için StateFlow döndürülür // ViewModel oluşturulduğunda haber verileri yüklenir fun onCreate() { scope.launch { // viewModelScope içinde coroutine başlatılır _uiState.value = NewsLoaded(newsRepository.getNews()) // Haber verileri yüklenir ve UI güncellenir } } }
Özel bir coroutine kapsamı, CoroutineScope fonksiyonu ile tanımlanır1. İçerisinde, pratikte standart uygulama
olarak SupervisorJob kullanılır2.
val analyticsScope = CoroutineScope(SupervisorJob()) // SupervisorJob kullanılarak özel bir coroutine kapsamı oluşturulur
Bir scope (kapsam) tanımında, bir dispatcher (dağıtıcı) veya bir exception handler (istisna işleyicisi)
belirtebiliriz3. Scope nesneleri aynı zamanda iptal edilebilir. Aslında, Android'de çoğu scope ya iptal edilir
ya da bazı koşullar altında çocuklarını iptal edebilir, ve "Bu işlemi çalıştırmak için hangi scope'u kullanmalıyım?"
sorusu genellikle "Bu işlem hangi koşullarda iptal edilmeli?" sorusuna indirgenebilir. View modelleri, scope'larını
temizlendiğinde iptal eder. Work manager'lar ise ilişkili görevler iptal edildiğinde scope'larını iptal eder.
// İptal ve istisna işleyicisi içeren Android örneği abstract class BaseViewModel : ViewModel() { private val _failure = Channel<Throwable>(Channel.UNLIMITED) // Hata kanalını tanımlar val failure: Flow<Throwable> = _failure.receiveAsFlow() // Hataları alacak bir flow oluşturur private val handler = CoroutineExceptionHandler { _, e -> // İstisna işleyicisi _failure.trySendBlocking(e) // Hata alındığında kanal üzerinden gönderilir } protected val viewModelScope = CoroutineScope( // ViewModel için özel bir coroutine scope oluşturulur Dispatchers.Main.immediate + SupervisorJob() + handler // Main thread ve SupervisorJob kullanılır ) override fun onCleared() { // ViewModel temizlendiğinde çalışır viewModelScope.coroutineContext.cancelChildren() // Tüm çocuk coroutineleri iptal eder } }
// Özelleştirilmiş istisna işleyicisiyle Spring örneği @Configuration class CoroutineScopeConfiguration { @Bean fun coroutineDispatcher(): CoroutineDispatcher = // CoroutineDispatcher'ı IO için sınırlı paralellik ile oluşturur Dispatchers.IO.limitedParallelism(50) @Bean fun coroutineExceptionHandler( monitoringService: MonitoringService, // İzleme servisi ile hata işleyici oluşturulur ) = CoroutineExceptionHandler { _, throwable -> monitoringService.reportError(throwable) // Hata meydana geldiğinde izleme servisi üzerinden raporlanır } @Bean fun coroutineScope( coroutineDispatcher: CoroutineDispatcher, // CoroutineDispatcher, önceki tanımla sağlanır coroutineExceptionHandler: CoroutineExceptionHandler, // İstisna işleyici, önceki tanımla sağlanır ) = CoroutineScope( // Özel bir CoroutineScope oluşturulur SupervisorJob() + // SupervisorJob, alt görevlerin kontrol edilmesini sağlar coroutineDispatcher + // Dispatcher, asenkron işlemler için belirlenir coroutineExceptionHandler // İstisna işleyici, hataları ele almak için eklenir ) }

runBlocking kullanımı

Coroutineleri bir scope (kapsam) nesnesi üzerinde başlatmak yerine, aynı zamanda runBlocking fonksiyonunu da
kullanabiliriz. Bu fonksiyon, bir coroutine başlatır ve bu coroutine bitene kadar mevcut iş parçacığını (
thread) bloklar. Bu nedenle, runBlocking yalnızca bir iş parçacığını bloklamak istediğimizde kullanılmalıdır.
Kullanımının en yaygın iki nedeni şunlardır:
  1. main fonksiyonunu sarmak için. Bu, runBlocking'in doğru bir kullanım şeklidir çünkü runBlocking tarafından
    başlatılan coroutine bitene kadar iş parçacığını bloklamak zorundayız.
  2. Test fonksiyonlarını sarmak için. Bu durumda da test iş parçacığını bloklamamız gerekir, böylece test, coroutine
    tamamlanana kadar çalışmaya devam eder.
import kotlinx.coroutines.runBlocking annotation class Test // Test fonksiyonlarını tanımlayan özel bir annotation (işaretleyici) sınıfı fun main(): Unit = runBlocking { // Main fonksiyonu bir coroutine içinde çalıştırılır // ... } class SomeTests { // Test sınıfı @Test // Test olarak işaretlenmiş bir fonksiyon fun someTest() = runBlocking { // Test fonksiyonu bir coroutine içinde çalıştırılır // ... } }
Her iki durumda da daha modern alternatifler mevcuttur. main fonksiyonunu coroutineScope veya testlerde runTest
ile askıya alabiliriz. Bu, runBlocking kullanımından kaçınmamız gerektiği anlamına gelmez, bazı durumlarda
ihtiyaçlarımız için yeterli olabilir.
import kotlinx.coroutines.coroutineScope // coroutineScope fonksiyonunu import eder import kotlinx.coroutines.test.runTest // runTest fonksiyonunu testler için import eder annotation class Test // Test fonksiyonlarını işaretlemek için kullanılan annotation sınıfı suspend fun main(): Unit = coroutineScope { // Main fonksiyonu bir coroutine içinde çalıştırılır // ... } class SomeTests { // Test sınıfı @Test // Test olarak işaretlenmiş bir fonksiyon fun someTest() = runTest { // Test fonksiyonu runTest ile çalıştırılır // ... } }
Diğer durumlarda, runBlocking kullanımından kaçınmalıyız. Unutmayın ki runBlocking mevcut iş parçacığını (thread)
bloklar, bu da Kotlin Coroutines'te kaçınılması gereken bir durumdur. runBlocking'i yalnızca mevcut iş parçacığını
kasıtlı olarak bloklamak istediğinizde kullanın.
class NotificationsSender( private val client: NotificationsClient, // Bildirimleri gönderen istemci private val notificationScope: CoroutineScope, // Bildirim göndermek için kullanılan scope (kapsam) ) { @Measure // Fonksiyonun çalışma süresi ölçülür fun sendNotifications(notifications: List<Notification>) { val jobs = notifications.map { notification -> // Her bildirim için bir iş (job) başlatılır scope.launch { // Bildirim gönderme işlemi coroutine içinde başlatılır client.send(notification) } } // Burada iş parçacığını bloklarız // Tüm bildirimler gönderilene kadar, fonksiyonun çalışması ölçülecektir // Böylece fonksiyonun doğru çalışma süresi ölçümü yapılır runBlocking { jobs.joinAll() } // Tüm işlemlerin tamamlanmasını bekleriz } }

Working with Flow (Flow ile çalışmak)

Flow'ları gözlemlerken, genellikle değişiklikleri onEach içinde işleriz, flow'umuzu başka bir coroutine
içinde launchIn kullanarak başlatırız, flow başladığında bir işlem yapmak için onStart kullanırız, flow
tamamlandığında bir işlem yapmak için onCompletion kullanırız ve istisnaları catch ile yakalarız. Eğer bir flow
içinde meydana gelebilecek tüm istisnaları yakalamak istiyorsak, catch'i son sırada belirtmeliyiz4.
fun updateNews() { newsFlow() // Haberleri döndüren flow başlatılır .onStart { showProgressBar() } // Flow başlamadan önce progress bar (yükleme çubuğu) gösterilir .onCompletion { hideProgressBar() } // Flow tamamlandığında progress bar gizlenir .onEach { view.showNews(it) } // Her bir haber öğesi için view'ı günceller .catch { view.handleError(it) } // Herhangi bir hata oluşursa, hatayı view'da gösterir .launchIn(viewModelScope) // Flow, viewModelScope içinde başlatılır }
Android'de, uygulama durumumuzu genellikle MutableStateFlow (değiştirilebilir StateFlow) türündeki özellikler içinde
view model sınıflarında temsil etmek popülerdir5. Bu özellikler, değişikliklerine göre view'ı güncelleyen
coroutineler tarafından gözlemlenir.
class NewsViewModel : BaseViewModel() { private val _loading = MutableStateFlow(false) // Yükleme durumu için StateFlow oluşturulur val loading: StateFlow<Boolean> = _loading // Yükleme durumu dışarıya okunabilir hale getirilir private val _news = MutableStateFlow(emptyList<News>()) // Haberler için StateFlow oluşturulur val news: StateFlow<List<News>> = _news // Haberler dışarıya okunabilir hale getirilir fun onCreate() { newsFlow() // Haber akışı başlatılır .onStart { _loading.value = true } // Akış başladığında yükleme durumu true yapılır .onCompletion { _loading.value = false } // Akış tamamlandığında yükleme durumu false yapılır .onEach { _news.value = it } // Her yeni haberle _news güncellenir .catch { _failure.value = it } // Hata durumunda _failure güncellenir .launchIn(viewModelScope) // Akış viewModelScope içinde çalıştırılır } } class LatestNewsActivity : AppCompatActivity() { @Inject val newsViewModel: NewsViewModel // ViewModel dependency injection ile eklenir override fun onCreate(savedInstanceState: Bundle?) { // ... launchOnStarted { // Akış başladığında çalışacak coroutine başlatılır newsViewModel.loading.collect { // loading StateFlow'u dinlenir progressBar.visbility = // Yükleme durumu progress bar'ı günceller if (it) View.VISIBLE else View.GONE } } launchOnStarted { // Akış başladığında çalışacak diğer coroutine başlatılır newsViewModel.news.collect { // news StateFlow'u dinlenir newsList.adapter = NewsAdapter(it) // Haberler listesine adapte edilir } } } }
Bir durumu temsil eden bir özellik yalnızca tek bir flow'a (akışa) bağlı olduğunda, stateIn metodunu kullanabiliriz.
started parametresine bağlı olarak, bu flow başlangıçta hemen (eagerly) başlatılabilir (bu sınıf başlatıldığında),
tembel bir şekilde (lazy) başlatılabilir (ilk eşzamanlı işlem (coroutine) verileri toplamaya başladığında) veya abone
olunduğu sürece (while subscribed) başlatılabilir6.
class NewsViewModel : BaseViewModel() { private val _loading = MutableStateFlow(false) // Yükleme durumu için StateFlow oluşturulur val loading: StateFlow<Boolean> = _loading // Yükleme durumu dışarıya okunabilir hale getirilir val newsState: StateFlow<List<News>> = newsFlow() // Haberleri döndüren flow başlatılır .onStart { _loading.value = true } // Akış başladığında yükleme durumu true yapılır .onCompletion { _loading.value = false } // Akış tamamlandığında yükleme durumu false yapılır .catch { _failure.value = it } // Hata durumunda _failure güncellenir .stateIn( // StateFlow başlatılır scope = viewModelScope, // viewModelScope içinde çalıştırılır started = SharingStarted.Lazily, // Flow, ilk abone olunduğunda başlatılır initialValue = emptyList(), // Başlangıç değeri boş liste olarak atanır ) }
class LocationsViewModel( locationService: LocationService // LocationService kullanılarak locationService parametresi alınır ) : ViewModel() { private val location = locationService.observeLocations() // Locations akışını başlatır .map { it.toLocationsDisplay() } // Location verilerini LocationsDisplay formatına dönüştürür .stateIn( // StateFlow başlatılır scope = viewModelScope, // Flow, viewModelScope içinde çalıştırılır started = SharingStarted.Lazily, // Flow, ilk abone olunduğunda başlatılır initialValue = LocationsDisplay.Loading, // Başlangıç değeri Loading (yükleme) olarak atanır ) // ... }
Bir durumu temsil etmek için StateFlow kullanılmalıdır. Birden fazla coroutine tarafından gözlemlenmesi gereken bazı
olaylar veya güncellemeler için ise SharedFlow kullanılmalıdır.
class UserProfileViewModel { private val _userChanges = // Kullanıcı değişikliklerini tutan MutableSharedFlow oluşturulur MutableSharedFlow<UserChange>() val userChanges: SharedFlow<UserChange> = _userChanges // Değişiklikler SharedFlow olarak dışa açılır fun onCreate() { viewModelScope.launch { // viewModelScope içinde bir coroutine başlatılır userChanges.collect(::applyUserChange) // userChanges dinlenir ve applyUserChange fonksiyonu ile işlenir } } fun onNameChanged(newName: String) { // ... _userChanges.emit(NameChange(newName)) // İsim değişikliği ile yeni bir NameChange olayı yayımlanır } fun onPublicKeyChanged(newPublicKey: String) { // ... _userChanges.emit(PublicKeyChange(newPublicKey)) // PublicKey değişikliği ile yeni bir PublicKeyChange olayı yayımlanır } }
  1. 1.Ayrıntılar için bkz. “Bir coroutine scope (iş kapsamı) oluşturma” bölümü. ↩
  2. 2.SupervisorJob’un nasıl çalıştığını öğrenmek için bkz. “İstisna Yönetimi” bölümü. ↩
  3. 3.Ayrıntılar için bkz. “Bir coroutine scope (iş kapsamı) oluşturma” bölümü. Dispatchers ve istisna işleyicileri hakkında bilgi için sırasıyla “İş Parçacığı Yöneticileri (Dispatchers)” ve “İstisna Yönetimi” bölümlerine bakınız. ↩
  4. 4.Ayrıntılar için bkz. “Flow Yaşam Döngüsü Fonksiyonları (Flow lifecycle functions)” bölümü. ↩
  5. 5.Ayrıntılar için bkz. “SharedFlow ve StateFlow” bölümü. ↩
  6. 6.Tüm bu seçenekler için bkz. “SharedFlow ve StateFlow” bölümü, “shareIn” ve “stateIn” alt başlıkları. ↩