Exceptions erneut auslösen und verketten
Lösen Sie Exceptions gezielt erneut aus und kapseln Sie Fehler niedrigerer Ebenen mit einer Cause-Kette.
Exceptions erneut auslösen und verketten ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.
Erneutes Auslösen und Wrapping
Manchmal fangen Sie eine Exception nur ab, um sie zu protokollieren, zu wrappen oder zu konvertieren, bevor Sie eine spezifischere Exception weiterreichen. Kotlin macht dieses Vorgehen idiomatisch.
Einfaches erneutes Auslösen
Um eine Exception erneut auszulösen, verwenden Sie einfach wieder throw e – die Weitergabe wird an den nächsten Handler fortgesetzt.
fun main() {
try {
try { "x".toInt() }
catch (e: NumberFormatException) {
println("logging: ${e.message}")
throw e // re-throw original
}
} catch (e: NumberFormatException) {
println("outer caught: ${e.message}")
}
}Mit einer benutzerdefinierten Exception wrappen
Übergeben Sie beim Erzeugen einer neuen Exception die ursprüngliche Exception als cause, damit die Kette erhalten bleibt.
class ParseException(msg: String, cause: Throwable) : RuntimeException(msg, cause)
fun main() {
try {
try { "xyz".toInt() }
catch (e: NumberFormatException) {
throw ParseException("could not parse user input", e)
}
} catch (e: ParseException) {
println("got: ${e.message}")
println("cause: ${e.cause?.message}")
}
}Die Ursachenkette untersuchen
Die Eigenschaft cause verweist auf die vorherige Exception. Durchlaufen Sie sie, um die vollständige ursprüngliche Ursache auszugeben.
fun main() {
val e = RuntimeException("top",
RuntimeException("middle",
RuntimeException("root")))
var current: Throwable? = e
while (current != null) {
println(current.message)
current = current.cause
}
}Selektives erneutes Auslösen
Fangen Sie einen allgemeinen Typ ab und lösen Sie die Exception erneut aus, wenn sie NICHT dem erwarteten Fall entspricht.
fun parseRequired(s: String): Int {
try {
return s.toInt()
} catch (e: NumberFormatException) {
if (s.isBlank()) return 0
throw e // unexpected — let it propagate
}
}
fun main() {
println(parseRequired("42"))
println(parseRequired(""))
// parseRequired("abc") // throws
}Kontext hinzufügen
Wrappen Sie die Exception mit einer Domänen-Exception, um Kontext hinzuzufügen, der der ursprünglichen Exception fehlte, etwa Eingabe oder Anfrage-ID.
class UploadError(msg: String, cause: Throwable) : RuntimeException(msg, cause)
fun upload(file: String) {
try { throw RuntimeException("disk full") }
catch (e: Throwable) { throw UploadError("uploading $file failed", e) }
}
fun main() {
try { upload("photo.jpg") }
catch (e: UploadError) { println("${e.message} <- ${e.cause?.message}") }
}Den Stacktrace nicht verlieren
Übergeben Sie beim Wrappen immer die ursprüngliche Exception als cause – erzeugen Sie niemals einfach eine neue Exception mit derselben Nachricht, aber ohne Ursache. Der Stacktrace ist Ihre wichtigste Hilfe beim Debuggen.
class Wrapped(m: String, cause: Throwable) : RuntimeException(m, cause)
fun main() {
try {
try { error("inner") }
catch (e: Throwable) { throw Wrapped("outer", e) }
} catch (e: Wrapped) {
println("message: ${e.message}")
println("cause: ${e.cause?.message}")
}
}Ohne Wrapping erneut auslösen
Wenn Sie nur protokollieren müssen, verwenden Sie nach dem Protokollieren einfach throw e – ein Wrapping ist nicht erforderlich.
fun risky() {
try { throw IllegalStateException("oops") }
catch (e: IllegalStateException) {
println("Logging before rethrow: ${e.message}")
throw e
}
}
fun main() {
try { risky() }
catch (e: IllegalStateException) { println("outer: ${e.message}") }
}finally zur Bereinigung beim erneuten Auslösen
Verwenden Sie finally, um Ressourcen auch beim erneuten Auslösen einer Exception zu bereinigen.
fun process() {
try {
throw RuntimeException("failure")
} finally {
println("cleanup ran")
}
}
fun main() {
try { process() }
catch (e: RuntimeException) { println("caught: ${e.message}") }
}Unterdrückte Exceptions
Wenn finally selbst eine Exception auslöst, wird die ursprüngliche Exception standardmäßig unterdrückt. Verwenden Sie addSuppressed, um beide zu erhalten.
fun main() {
val primary = RuntimeException("primary")
val secondary = RuntimeException("from cleanup")
primary.addSuppressed(secondary)
println(primary.suppressed.joinToString { it.message ?: "?" })
}Anti-Pattern: Eine andere Exception auslösen, nachdem eine Exception verschluckt wurde
Eine Exception abzufangen und ohne Ursache eine neue, in keinem Zusammenhang stehende auszulösen, zerstört Debugging-Informationen. Übergeben Sie immer cause.
// BAD
// catch (e: IOException) { throw RuntimeException("error") }
// GOOD
// catch (e: IOException) { throw RuntimeException("error reading config", e) }
fun main() { println("Pass cause when re-throwing!") }Kurztest
Was sollten Sie tun, wenn Sie eine Exception in eine neue verpacken, um den ursprünglichen Stacktrace zu erhalten?
Zusammenfassung
Zum erneuten Auslösen: throw e. Zum Wrappen: Lösen Sie eine neue Exception mit cause = e aus. Bewahren Sie immer die Ursachenverkettung — erzeugen Sie niemals einen Wrapper ohne Ursache. Verwenden Sie finally für Aufräumarbeiten und addSuppressed, wenn die Aufräumarbeit selbst fehlschlägt.
Häufig gestellte Fragen
Ist die Lektion „Exceptions erneut auslösen und verketten“ kostenlos?
Ja — der vollständige Text von „Exceptions erneut auslösen und verketten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Exceptions erneut auslösen und verketten“?
Lösen Sie Exceptions gezielt erneut aus und kapseln Sie Fehler niedrigerer Ebenen mit einer Cause-Kette. Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Kotlin Academy zu starten?
Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Exceptions erneut auslösen und verketten“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?
Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- try/catch/finally als Ausdruck
- Benutzerdefinierte Exception-Klassen erstellen
- runCatching und Result
- Exceptions erneut auslösen und verketten