Лучшие практики обработки ошибок в Kotlin

Каждый язык программирования должен обеспечивать обработку ошибок, что справедливо и для Kotlin — он обладает мощными возможностями, которые делают обработку ошибок простой и эффективной.

Одним из наиболее значимых преимуществ обработки ошибок в Kotlin является возможность лаконичной и понятной обработки исключений. Эта возможность помогает разработчикам быстро находить и устранять ошибки, сокращая время на отладку кода.

Kotlin обладает основными возможностями обработки ошибок, такими как Null Safety, let, оператор Элвис (?:), поздняя инициализация, безопасное приведение с помощью оператора ‘as?’. Другие продвинутые техники обработки ошибок в Kotlin мы рассмотрим ниже.

Исключения в корутинах

При возникновении исключения короутин передает его родителю. После этого родительская программа:

1. отменит себя
2. отменит оставшиеся дочерние функции
3. передаст исключение своему родителю.

Все корутины, запущенные CoroutineScope, будут отменены, как только исключение достигнет вершины иерархии.

1. Отменит себя

import kotlinx.coroutines.*

fun main() = runBlocking {
    val parentJob = GlobalScope.launch {
        val childJob = launch {
            throw RuntimeException("Exception occurred in child coroutine!")
        }
        try {
            childJob.join()
            println("Child job completed successfully")
        } catch (e: Exception) {
            println("Caught exception in parent: ${e.message}")
        }
    }

    parentJob.join()
    println("Parent job completed")
}

В данном примере мы имеем родительскую программу (parentJob), которая запускает дочернюю программу (childJob). Дочерняя программа намеренно выбрасывает RuntimeException, чтобы имитировать сбой.

2. Отменит оставшиеся дочерние функции

import kotlinx.coroutines.*

fun main() = runBlocking {
    val parentJob = GlobalScope.launch {
        val childJob1 = launch {
            delay(1000)
            throw RuntimeException("Exception occurred in child job 1!")
        }
        val childJob2 = launch {
            delay(2000)
            println("Child job 2 completed successfully")
        }
        val childJob3 = launch {
            delay(3000)
            println("Child job 3 completed successfully")
        }
        try {
            childJob1.join()
        } catch (e: Exception) {
            println("Caught exception in parent: ${e.message}")
        }
    }

    parentJob.join()

В данном примере мы имеем родительскую корутину (parentJob), которая запускает три дочерние корутины (childJob1, childJob2, childJob3). Первое дочернее задание намеренно выбрасывает RuntimeException после задержки, имитируя сбой.

3. Передаст исключение своему родителю

import kotlinx.coroutines.*

fun main() = runBlocking {
    val parentJob = GlobalScope.launch {
        val childJob = launch {
            throw RuntimeException("Exception occurred in child coroutine!")
        }
        try {
            childJob.join()
        } catch (e: Exception) {
            println("Caught exception in parent: ${e.message}")
            throw e // Rethrow the exception
        }
    }

    try {
        parentJob.join()
    } catch (e: Exception) {
        println("Caught exception in top-level coroutine: ${e.message}")
    }

    println("Coroutine execution completed")
}

В данном примере родительская программа запускает дочернюю программу, которая намеренно выбрасывает исключение RuntimeException. Когда исключение возникает в дочерней программе, она передает его своей родительской программе.

Использование Sealed классов для обработки ошибок

Sealed класс предоставляет мощный способ моделирования класса ошибок в Kotlin.

Определив иерархию изолированных классов, представляющих все возможные ошибки в вашем приложении, вы сможете легко и эффективно обрабатывать ошибки.

sealed class AppState {
  object Loading : AppState()
  object Ready : AppState()
  object Error : AppState()
}

fun handleAppState(state: AppState) {
  when (state) {
    is AppState.Loading -> {
      // Do something when the app is loading
    }
    is AppState.Ready -> {
      // Do something when the app is ready
    }
    is AppState.Error -> {
      // Do something when the app has an error
    }
  }
}

Код включает функцию handleAppState, которая управляет различными состояниями приложения, представленными AppState. Она реагирует на состояния загрузки, готовности и ошибки, выполняя соответствующие действия с помощью выражения when.

Функциональная обработка ошибок

Функциональная обработка ошибок — это важный метод, в котором применяются функции высшего порядка. Вы можете быстро разработать логику обработки ошибок и отказаться от вложенных операторов if-else, передавая процедуры обработки ошибок в качестве входных данных другим частям программы.

fun <T> Result<T>.onError(action: (Throwable) -> Unit): Result<T> {
            if (isFailure) {
                action(exceptionOrNull())
            }
            return this
        }
        
fun loadData(): Result<Data> {
            return Result.success(Data())
        }
        
loadData().onError { e -> Log.e("TAG", e.message) }

В коде определена функция onError для обработки ошибок Result с действием по умолчанию для сбоев. При успешной загрузке данных возвращается объект данных Result. Если при загрузке данных возникают исключения, пример выводит сообщения об ошибках в лог.

Обработчики невыясненных исключений

Вы можете сконфигурировать обработчик не пойманных исключений для обработки любых необработанных исключений, возникающих в вашем приложении. Такой подход позволяет регистрировать ошибки или выдавать удобные для пользователя сообщения до того, как приложение потерпит крах.

Ниже приведен пример настройки обработчика неперехваченных исключений:

Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
    // Handle the uncaught exception here
    Log.e("AppCrash", "Uncaught exception occurred: $throwable")
    // Perform any necessary cleanup or show an error dialog
    // ...
}

С помощью Thread.setDefaultUncaughtExceptionHandler в коде создается обработчик невыловленных исключений по умолчанию. Неперехваченные исключения регистрируются в Log.e. А потом обработчик может запустить  соответствующее представление ошибки или собственное отображение.

Обработка сетевых ошибок в Retrofit

Создав уникальный конвертер ошибок, вы можете использовать возможности Retrofit по обработке ошибок при работе с сетевыми запросами. Это позволит более системно подходить к обработке различных кодов ошибок HTTP и сетевых проблем.

Например:

class NetworkException(message: String, cause: Throwable? = null) : Exception(message, cause)

interface MyApiService {
    @GET("posts")
    suspend fun getPosts(): List<Post>
}

val retrofit = Retrofit.Builder()
    .baseUrl(BASE_URL)
    .addConverterFactory(GsonConverterFactory.create())
    .addCallAdapterFactory(CoroutineCallAdapterFactory())
    .build()

val apiService = retrofit.create(MyApiService::class.java)

try {
    val posts = apiService.getPosts()
    // Process the retrieved posts
} catch (e: HttpException) {
    // Handle specific HTTP error codes
    when (e.code()) {
        404 -> {
            // Handle resource not found error
        }
        // Handle other error codes
    }
} catch (e: IOException) {
    // Handle network-related errors
    throw NetworkException("Network error occurred", e)
} catch (e: Exception) {
    // Handle other generic exceptions
}

Интерфейсы NetworkException и MyApiService определены в коде для сетевых операций Retrofit. Он выполняет сетевой вызов для получения сообщений, управляя исключениями, связанными с HTTP и сетью, с помощью блоков try-catch и соответствующих методов обработки ошибок.

Красивая обработка ошибок с помощью корутинов

При использовании корутинов можно выполнить приостановленное действие и изящно обработать любые исключения с помощью функции runCatching. Эта функция упрощает структуру кода, позволяя собирать и обрабатывать исключения в рамках одного блока.

Например:

suspend fun fetchData(): Result<Data> = coroutineScope {
    runCatching {
        // Perform asynchronous operations
        // ...
        // Return the result if successful
        Result.Success(data)
    }.getOrElse { exception ->
        // Handle the exception and return an error result
        Result.Error(exception.localizedMessage)
    }
}

// Usage:
val result = fetchData()
when (result) {
    is Result.Success -> {
        // Handle the successful result
    }
    is Result.Error -> {
        // Handle the error result
    }
}

Suspend функция программы fetchData использует корутины для выполнения асинхронных задач. Для обработки исключений она использует runCatching и возвращает Result, который либо указывает на успешное получение данных, либо на ошибку с ее описанием. В примере показано, как использовать fetchData и работать с успешными результатами или ошибками.

Обработка ошибок с RXJava

Операторы — это функции RxJava, которые позволяют работать с данными, выдаваемыми Observables. Ниже приведены операторы RxJava, используемые для обработки ошибок:

1. onExceptionResumeNext()
2. onErrorResumeNext()
3. doOnError()
4. onErrorReturnItem()
5. onErrorReturn()

Заключение

Сильные возможности Kotlin по обработке ошибок делают его более простым и эффективным для разработчиков. Его исключительная обработка исключений внутри корутинов является одним из важнейших преимуществ. Исключения легко распространяются по иерархии корутинов, что позволяет точно управлять корутинами и отменять их работу.

Следуя этим рекомендациям и используя возможности Kotlin по обработке ошибок, разработчики смогут создавать более надежный код в своих Kotlin-приложениях.

Источник