rzaripov.kz

Перехват исключений в Kotlin для стабильности приложения

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

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

Границы ответственности за ошибки

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

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

Общий Throwable удобен для перехвата всего, но опасен: вместе с Exception он включает OutOfMemoryError, StackOverflowError и другие состояния, из которых программа не может штатно восстановиться. В обычном коде применяют конкретные типы ошибок, а CancellationException всегда повторно выбрасывают, поскольку отмена корутины — управляющий сигнал, а не сбой.

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

Глобальный обработчик нужен как последний рубеж перед завершением процесса. Он не заменяет локальную обработку и не позволяет продолжить повреждённый поток, но даёт единое место для сохранения стека, имени потока и причины фатальной ошибки. На Android и других JVM-платформах для этого используется Thread.UncaughtExceptionHandler.

import kotlin.system.exitProcess

fun interface CrashRecorder {
    fun record(threadName: String, error: Throwable)
}

fun installCrashHandler(recorder: CrashRecorder) {
    val previous = Thread.getDefaultUncaughtExceptionHandler()

    Thread.setDefaultUncaughtExceptionHandler { thread, error ->
        runCatching {
            recorder.record(thread.name, error)
        }

        if (previous != null) {
            previous.uncaughtException(thread, error)
        } else {
            exitProcess(1)
        }
    }
}

При установке обработчика важно сохранить предыдущую цепочку и не менять поведение завершения процесса. Делегирование исходному обработчику позволяет SDK и среде выполнения выполнить собственные действия. Если предыдущего обработчика нет, процесс нужно завершить явно; иначе главный поток может завершиться, оставив приложение в неопределённом состоянии.

Сама запись отчёта должна быть минимальной и безопасной: нельзя выполнять длительную сеть, сложное шифрование или создавать большие объекты, когда ресурсы уже могут быть исчерпаны. Полезно сохранить версию сборки, контекст операции и идентификатор связанного запроса, исключив персональные данные и секреты. Обработчик устанавливают один раз, чтобы не дублировать отчёты при повторной инициализации.

Локальный перехват и типизация ошибок

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

suspend fun loadProfile(): Profile {
    return try {
        repository.loadProfile()
    } catch (error: CancellationException) {
        throw error
    } catch (error: IOException) {
        Profile.empty()
    }
}
Механизм Что обрабатывает Как проявляется ошибка Подходящее применение
try и catch Известную операцию Исключение сразу обрабатывается или передаётся дальше Граница с понятным восстановлением
Result Ожидаемый отказ Значение содержит либо результат, либо причину Публичный контракт функции
runCatching Любой Throwable внутри блока Ошибка превращается в неуспешный результат Небольшой синхронный фрагмент
CoroutineExceptionHandler Необработанную ошибку корневой корутины Выполняется финальная диагностика Верхняя граница фоновой работы
Thread.UncaughtExceptionHandler Необработанную ошибку потока Процесс готовится к завершению Последний рубеж на JVM и Android

Result выражает ожидаемый отказ как значение и делает его частью контракта функции. Это удобно для парсинга, проверки ввода и вызовов, где вызывающий код обязан обработать неудачу. Однако runCatching перехватывает любой Throwable, включая отмену корутины и серьёзные ошибки среды, поэтому в suspend-функциях его применение требует особой осторожности.

Для асинхронного кода предпочтительны явные catch с понятной иерархией. Если из операции можно вернуть кэш или пустое состояние, это отражается в типе; если продолжение невозможно, исключение распространяется вверх до подходящей границы. Такой подход сохраняет первоначальную причину и упрощает тестирование.

fun parseConfig(raw: String): Result<Config> =
    try {
        Result.success(Config.parse(raw))
    } catch (error: IllegalArgumentException) {
        Result.failure(error)
    }

Особенности корутин и отмены задач

В корутинах ошибка распространяется по правилам структурированной конкурентности. Необработанная ошибка в launch отменяет родительскую задачу, а CoroutineExceptionHandler используется для финальной обработки на верхней границе. Обработчик не делает операцию успешной: отмена и очистка ресурсов всё равно выполняются.

Для длительных фоновых задач полезен отдельный scope с SupervisorJob: сбой одного дочернего launch не отменяет остальные задачи. Обработчик размещают в контексте scope, чтобы наследовать его всеми запущенными корутинами.

private val errorHandler = CoroutineExceptionHandler { _, error ->
    crashReporter.record(error)
}

private val appScope = CoroutineScope(
    SupervisorJob() + Dispatchers.Default + errorHandler
)

fun scheduleRefresh() {
    appScope.launch {
        repository.refresh()
    }
}

async хранит исключение в объекте Deferred до вызова await. Поэтому в обычном coroutineScope такая ошибка может отменить родителя ещё до чтения результата, а в supervisorScope — не затронуть соседние задачи, но всё равно будет повторно выброшена при await. Вызывающий код должен явно получить и обработать этот результат.

CancellationException относится к нормальному завершению отменённой задачи. Её нельзя превращать в Result.failure, отправлять в отчёт о падениях или проглатывать блоком catch: это нарушает отмену и может оставить родительскую корутину в неправильном состоянии. В finally освобождают ресурсы, но не скрывают исходную причину.

Проверка, диагностика и кроссплатформенность

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

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

На JVM и Android глобальный обработчик доступен непосредственно, но в Kotlin Multiplatform код восстановления и интерфейс отчёта лучше вынести в общий модуль, а платформенную запись реализовать через expect и actual. Это сохраняет одинаковую политику ошибок в приложениях для разных операционных систем, учитывая различия в модели потоков и завершении процесса. В устойчивой архитектуре локальное восстановление, контролируемая отмена и финальная диагностика работают как единый контур, а не как набор случайных catch.