Java programátor expert
Java Exception Handling: Ako správne ošetriť výnimky v Jave
Java exception handling je mechanizmus na spracovanie chýb, ktoré vznikajú počas behu aplikácie. V tomto tutoriáli sa naučíš pracovať s výnimkami v Jave od hierarchie Throwable cez bloky try-catch a try-with-resources až po tvorbu vlastných výnimiek a osvedčené postupy používané v praxi.
V článku sa dozvieš:
Java exception handling najlepšie pochopíš na situáciách, ktoré sa bežne stávajú v produkcii. Počas vývoja môže aplikácia fungovať bez problémov, no v reálnom nasadení sa skôr či neskôr objaví chyba. Môže chýbať konfiguračný súbor, databáza nemusí byť dostupná, používateľ zadá neplatné údaje alebo zlyhá sieťová komunikácia. Ak aplikácia takéto situácie neošetrí, často skončí pádom alebo sa začne správať nepredvídateľne.
Cieľom exception handlingu nie je zachytiť každú výnimku za každú cenu. Dôležité je vedieť, kde má zmysel výnimku spracovať, kedy ju nechať propagovať vyššie a v akých prípadoch vytvoriť vlastnú výnimku. Práve správne navrhnuté spracovanie výnimiek robí aplikáciu spoľahlivejšou a zároveň uľahčuje jej údržbu aj ďalší vývoj.
Čo je výnimka v Jave a prečo vzniká
Java výnimka je udalosť, ktorá nastane počas vykonávania programu a naruší jeho štandardný tok inštrukcií. Treba pochopiť, že v Jave je výnimka objekt. Keď dôjde k chybe, runtime prostredie (JVM) vytvorí objekt príslušnej triedy výnimky, ktorý obsahuje podrobnosti o tom, čo sa stalo a kde presne v kóde k problému došlo.
Životný cyklus výnimky
Celý proces spracovania sa točí okolo troch hlavných fáz:
- Vyvolanie (throwing): metóda, v ktorej nastala chyba, vytvorí objekt výnimky a odovzdá ho runtime systému. Tento proces nazývame vyvolanie výnimky pomocou kľúčového slova throw.
- Hľadanie handlera: JVM začne prehľadávať zásobník volaní (call stack) smerom nadol a hľadá blok kódu, ktorý je schopný danú výnimku spracovať.
- Zachytenie (catching): ak sa nájde vhodný handler, výnimka sa mu odovzdá na spracovanie. Ak sa žiaden nenájde, program sa v danom vlákne ukončí, čo je stav, ktorému sa chceme vyhnúť.
Správne pochopenie tohto cyklu je prvým krokom k zvládnutiu logiky Java try catch a k písaniu kódu, ktorý prežije aj neočakávané stavy.
Hierarchia výnimiek v Jave: kto je kto v rodine Throwable
Hierarchia výnimiek (exception hierarchy) má v Jave jasný rodokmeň a určuje, ako sa jednotlivé typy výnimiek (exception types) správajú. Všetky triedy, ktoré reprezentujú chyby alebo výnimky v Jave, dedia od spoločného predka, triedy java.lang.Throwable. V hierarchii Throwable sú dve hlavné vetvy: Exception a Error.
Trieda Error: keď sa systém rúca
Trieda Error reprezentuje kritické stavy, ktoré vznikajú v samotnej JVM alebo v operačnom systéme:
- Príklady: OutOfMemoryError, StackOverflowError, VirtualMachineError.
- Charakteristika: tieto chyby sú zvyčajne fatálne. Aplikácia by sa ich nemala pokúšať zachytávať pomocou try-catch, pretože po ich vzniku je stav systému nestabilný. Ak ti dôjde pamäť, catch blok ti pravdepodobne nepomôže, pretože na jeho vykonanie už nezostali zdroje priradené operačným systémom.
Checked exceptions: povinnosť kompilátora
Trieda Exception a jej potomkovia (s výnimkou RuntimeException) tvoria skupinu kontrolovaných výnimiek (checked exceptions). Sú to udalosti, ktoré programátor musí predvídať:
- Príklady: IOException, SQLException, FileNotFoundException.
- Pravidlo: ak metóda vyhadzuje checked exception, volajúci kód ju musí buď ošetriť v catch bloku, alebo deklarovať jej šírenie ďalej pomocou kľúčového slova throws. Kompilátor ti nedovolí kód ani spustiť, ak toto pravidlo ignoruješ. Toto je jadro mechanizmu Java exception handling, ktoré nás núti premýšľať o chybách už počas písania kódu.
Unchecked exceptions (runtime): logické chyby
Tieto výnimky dedia od triedy RuntimeException. Na rozdiel od kontrolovaných výnimiek kompilátor nevyžaduje ich povinné ošetrenie, preto sa im hovorí aj nekontrolované výnimky (unchecked exceptions):
- Príklady: NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException, IllegalArgumentException.
- Charakteristika: väčšinou ide o výsledok zlej programátorskej logiky. Napríklad pokus o prístup k metóde na objekte, ktorý je null, alebo delenie nulou. Tieto chyby by sa mali riešiť vylepšením logiky (napríklad validáciou vstupov), nie masívnym obaľovaním každého riadku do try-catch blokov.
Vieš, že…
…ti od Javy 15 hlásenie NullPointerException presne povie, ktorá časť výrazu bola null? Ušetrí ti tak hodiny hľadania v dlhých reťazcoch volaní.
V rámci ekosystému Java je pochopenie objektovej hierarchie základom. Ak sa chceš dozvedieť viac o tom, ako objekty v Jave vznikajú a ako s nimi pracovať, odporúčam pozrieť si články venované objektovo-orientovanému programovaniu, kde rozoberáme dedičnosť a polymorfizmus, čo sú princípy, na ktorých stojí aj celá štruktúra Throwable.
Základné mechanizmy spracovania: try, catch a finally
Ošetrovanie výnimiek v Jave stojí na troch (respektíve štyroch) kľúčových slovách. Tento mechanizmus umožňuje oddeliť logiku spracovania chýb od hlavnej biznis logiky programu, čo dramaticky zvyšuje čitateľnosť kódu.
Blok try-catch: prvá línia obrany
Blok Java try catch je základným stavebným kameňom. Do bloku try umiestňuješ kód, o ktorom vieš, že môže vyvolať výnimku (napríklad pri načítaní konfiguračného súboru aplikácie alebo sieťovej komunikácii). Ak k chybe dôjde, vykonávanie v rámci try bloku sa okamžite preruší a riadenie preberá príslušný catch blok.
try {
int result = 10 / 0; // Toto vyvolá ArithmeticException
System.out.println("Tento text sa nikdy nevypíše");
} catch (ArithmeticException e) {
System.err.println("Chyba: Delenie nulou nie je povolené. Detaily: " + e.getMessage());
}
Pri písaní catch blokov platí dôležité pravidlo: buď špecifický. Zachytávanie všeobecnej triedy Exception je síce pohodlné, ale v praxi nebezpečné, pretože môžeš nechtiac potlačiť aj chyby, o ktorých potrebuješ vedieť (napríklad chyby v pamäti alebo logické prešľapy).
Multi-catch: elegantné riešenie duplicity
Pred verziou Java 7 sme museli pre každý typ výnimky písať samostatný catch blok, aj keď reakcia na ne bola identická. To viedlo k zbytočnému opakovaniu kódu. Dnešná Java umožňuje zachytiť viacero typov výnimiek v jednom bloku pomocou operátora |.
try {
// Kód, ktorý môže vyhodiť rôzne výnimky
loadDataFromExternalSource();
} catch (IOException | SQLException e) {
// Spoločné spracovanie pre obe výnimky
logger.error("Nastala chyba pri práci s dátami", e);
}
Dôležitým technickým detailom pri multi-catch bloku je, že premenná výnimky (v tomto prípade e) je implicitne final. To znamená, že jej v rámci catch bloku nemôžeš priradiť novú hodnotu. Tento prístup robí Java exception handling čistejším a menej náchylným na chyby pri modifikácii stavu výnimky.
Význam bloku finally: posledné slovo v tvojom kóde
Blok finally je špecifický tým, že sa vykoná vždy, bez ohľadu na to, či k výnimke došlo alebo nie. Dokonca sa vykoná aj v prípade, ak v bloku try alebo catch použiješ príkaz return.
Jeho primárnou úlohou je upratovanie (cleanup). V starších verziách Javy sa tu uzatvárali súbory, databázové spojenia alebo sieťové sockety.
Prečo je finally kriticky dôležité
Ak tvoj kód otvorí spojenie s databázou a následne nastane výnimka, bez bloku finally by toto spojenie zostalo visieť otvorené v pamäti. Pri tisíckach požiadaviek by tvoja aplikácia rýchlo vyčerpala dostupné zdroje a skolabovala by.
Scanner scanner = null;
try {
scanner = new Scanner(new File("config.txt"));
// spracovanie súboru
} catch (FileNotFoundException e) {
System.err.println("Súbor sa nenašiel.");
} finally {
if (scanner != null) {
scanner.close(); // Toto sa vykoná v každom prípade
System.out.println("Prostriedky boli uvoľnené.");
}
}
Existujú len extrémne výnimky, kedy sa finally nevykoná:
- Ak JVM počas vykonávania try alebo catch bloku násilne skončí (napríklad cez System.exit(0)).
- Ak nastane fatálny výpadok hardvéru alebo pád operačného systému.
- Ak sa vlákno, v ktorom kód beží, násilne ukončí.
V modernom vývoji však klasický blok finally ustupuje do úzadia v prospech automatizácie, ktorú priniesla Java 7.
Moderná Java a try-with-resources
Kto písal kód v starších verziách Javy, pozná nekonečné a neprehľadné bloky v finally, kde bolo treba manuálne zatvárať každý stream, socket alebo databázové spojenie. Stačilo zabudnúť na jeden close() a aplikácia začala strácať pridelené zdroje (resource leak), spotrebovávala dostupnú pamäť a systémové prostriedky, až kým úplne nezlyhala.
S príchodom Javy 7 sa tento prístup stal minulosťou vďaka konštrukcii try-with-resources. Tento mechanizmus zabezpečuje, že každý zdroj deklarovaný v hlavičke bloku try sa automaticky uzavrie hneď po skončení bloku, a to aj v prípade, že nastala výnimka.
Rozhranie AutoCloseable: vstupenka do moderného sveta
Objekt sa dá použiť v rámci try-with-resources len vtedy, ak implementuje rozhranie java.lang.AutoCloseable (prípadne jeho predka java.io.Closeable). Väčšina štandardných tried v Jave, ktoré pracujú s I/O (vstupom a výstupom), toto rozhranie už dávno implementuje.
Prečo je bezpečnejšie použiť try-with-resources namiesto bloku finally?
Hlavným prínosom je eliminácia potlačených výnimiek (suppressed exceptions). V starom štýle s finally sa mohlo stať, že výnimka vznikla v bloku try aj pri zatváraní v bloku finally. V takom prípade pôvodná výnimka z try zanikla a bola prepísaná tou z finally, čo výrazne sťažovalo ladenie. Try-with-resources tento problém rieši inteligentne: primárna výnimka sa zachová a tie sekundárne zo zatvárania sú k nej pripojené ako potlačené.
Tu je praktická ukážka čítania zo súboru:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class ResourceHandler {
public void readFile(String filePath) {
// Zdroj je deklarovaný priamo v okrúhlych zátvorkách za try
try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
// Spracovanie chyby pri čítaní alebo otváraní súboru
System.err.println("Nepodarilo sa spracovať súbor: " + e.getMessage());
}
// Po skončení bloku sa reader.close() zavolá automaticky
}
}
Všimni si, že kód je oveľa stručnejší a čitateľnejší. Nemusíš deklarovať premennú mimo bloku a v finally kontrolovať, či nie je null.
Viacnásobné zdroje
V rámci jedného bloku môžeš otvoriť aj viacero zdrojov naraz. Stačí ich oddeliť bodkočiarkou. Budú sa uzatvárať v opačnom poradí, v akom boli vytvorené.
try (
InputStream input = new FileInputStream("source.txt");
OutputStream output = new FileOutputStream("destination.txt")
) {
// Logika kopírovania dát
} catch (IOException e) {
// Spracovanie I/O chýb
}
Šírenie výnimiek: kľúčové slová throw vs. throws
V rámci Java exception handling stratégie je kľúčové rozhodnúť sa, kto je za chybu zodpovedný. Musíš si položiť otázku: „Mám dostatok informácií na vyriešenie tejto chyby tu a teraz, alebo je lepšie nechať o tom vedieť kód, ktorý moju metódu zavolal?“
Kľúčové slovo throw
Príkaz throw sa používa na manuálne vyvolanie výnimky. Použiješ ho vtedy, keď tvoj kód narazí na stav, ktorý považuješ za chybný (napríklad neplatný parameter v metóde).
public void setAge(int age) {
if (age < 0 || age > 150) {
// Ručne vyvoláme runtime výnimku, ak je vek nezmyselný
throw new IllegalArgumentException("Vek musí byť v rozmedzí 0 až 150 rokov.");
}
this.age = age;
}
Kľúčové slovo throws
Zatiaľ čo throw výnimku vyvoláva, throws slúži na jej deklaráciu v signatúre metódy. Je to varovanie pre každého, kto chce túto metódu použiť: „Pozor, táto operácia môže zlyhať na týchto konkrétnych chybách, priprav sa na ne.“
Tento mechanizmus sa týka predovšetkým kontrolovaných výnimiek. Ak tvoja metóda pracuje s databázou a nechceš v nej riešiť SQLException, musíš ju priznať v hlavičke metódy.
public void processTransaction() throws SQLException, ConnectException {
// Kód, ktorý môže vyvolať uvedené výnimky
databaseService.execute();
}
Strategické rozhodovanie: kedy delegovať
Začiatočníci majú často tendenciu zachytávať všetko hneď tam, kde to vznikne. To je však často chyba. Ak vyvíjaš knižnicu alebo nízkoúrovňovú službu, zvyčajne nemáš predstavu o tom, ako by sa mal zachovať koncový používateľ aplikácie (či má zobraziť chybové okno, skúsiť operáciu znova, alebo len zapísať záznam do logu). V takom prípade je správne použiť throws a nechať rozhodnutie na vyššiu vrstvu architektúry.
Vlastné výnimky (custom exceptions): kedy ich vytvárať a ako ich navrhovať
Aj keď Java ponúka bohatú paletu predpripravených tried, v reálnych projektoch skôr či neskôr narazíš na limity. Štandardné výnimky sú často príliš technické a málo hovoria o biznis logike tvojej aplikácie. Práve tu prichádzajú na rad vlastné výnimky (custom exceptions).
Prečo definovať vlastné typy
Vlastná trieda výnimky rieši v projekte tri konkrétne veci:
- Doménový kontext: InsufficientFundsException povie vývojárovi oveľa viac ako všeobecný IllegalStateException.
- Cielené zachytávanie: umožňuje ti zachytiť presne tú chybu, ktorú chceš spracovať, bez rizika, že omylom odchytíš inú systémovú chybu rovnakého typu.
- Dodatočné dáta: do vlastnej výnimky môžeš pridať polia, ako sú chybové kódy, ID používateľa alebo časové pečiatky, čo uľahčuje následnú diagnostiku.
Implementácia v praxi
Pri vytváraní vlastnej výnimky sa musíš rozhodnúť, či bude kontrolovaná (dedí od Exception) alebo nekontrolovaná (dedí od RuntimeException). Trend v modernom vývoji, vrátane frameworkov ako Spring, sa prikláňa skôr k RuntimeException, pretože nespôsobuje zbytočné znečistenie signatúr metód.
public class UserNotFoundException extends RuntimeException {
private final String userId;
public UserNotFoundException(String message, String userId) {
super(message);
this.userId = userId;
}
public String getUserId() {
return userId;
}
}
Pri vyvolávaní tejto výnimky potom odovzdávaš správu aj konkrétny kontext:
public User findUser(String id) {
return userRepository.findById(id)
.orElseThrow(() -> new UserNotFoundException("Používateľ nebol nájdený v systéme", id));
}
Moderná Java (od verzie 8 vyššie) priniesla funkcionálnu paradigmu, ktorá výrazne zmenila spôsob, akým narábame s dátami. Spolu s tým sa objavila nová výzva: Java exception handling v prostredí lambda výrazov a prúdov (streams) nie je taký priamočiary ako v klasických cykloch.
Výnimky v modernej Jave: Stream API a Optional
Pri prvom pokuse použiť vo vnútri Streamu metódu, ktorá vyhadzuje kontrolovanú výnimku, narazíš na nepríjemnú bariéru. Štandardné funkcionálne rozhrania v Jave, ako Function, Predicate alebo Consumer, totiž vo svojej definícii nepočítajú s deklarovanými výnimkami.
Optional: elegantná alternatíva k výnimkám
Predtým, než sa pustíme do boja s chybami v Streamoch, musíme spomenúť Optional. Jeho cieľom nie je nahradiť kompletný mechanizmus výnimiek, ale eliminovať najbežnejšiu chybu v histórii Javy: slávnu výnimku NullPointerException.
Optional používaj vtedy, keď je neprítomnosť hodnoty očakávaným výsledkom operácie, nie chybou systému.
public Optional<User> findUserByEmail(String email) {
// Namiesto vracania null alebo vyhadzovania výnimky vrátime Optional
return userRepository.findByEmail(email);
}
// Použitie na strane volajúceho
findUserByEmail("test@msg.sk")
.map(User::getName)
.orElse("Anonymný používateľ");
Ak je však neprítomnosť hodnoty kritickým zlyhaním, Optional ti ponúka elegantné prepojenie na Java throw pomocou metódy orElseThrow().
User user = userRepository.findByEmail(email)
.orElseThrow(() -> new UserNotFoundException("Používateľ s daným emailom neexistuje", email));
Problém s checked exceptions v Streamoch
Predstav si, že máš zoznam ciest k súborom a chceš ich všetky načítať. Metóda Files.readString() vyhadzuje IOException, takže nasledujúci kód sa neskompiluje:
List<String> contents = paths.stream()
.map(path -> Files.readString(path)) // Kompilačná chyba: Unhandled exception: java.io.IOException
.collect(Collectors.toList());
Prečo? Pretože rozhranie Function<T, R>, ktoré metóda map očakáva, nemá v signatúre throws IOException. Máš v zásade tri možnosti, ako to vyriešiť.
1. Try-catch priamo v lambde (krkolomné riešenie)
Toto riešenie funguje, ale drasticky znižuje čitateľnosť a popiera eleganciu Streamov.
List<String> contents = paths.stream()
.map(path -> {
try {
return Files.readString(path);
} catch (IOException e) {
throw new UncheckedIOException(e); // Obalíme do runtime výnimky
}
})
.collect(Collectors.toList());
2. Extrahovanie logiky do helper metódy
Tento prístup je oveľa čistejší. Vytvoríš si metódu, ktorá sa postará o obalenie (wrapping) výnimky, a v Streame použiješ referenciu na túto metódu.
private String readStringUnchecked(Path path) {
try {
return Files.readString(path);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
// V streame to potom vyzerá profesionálne
List<String> contents = paths.stream()
.map(this::readStringUnchecked)
.collect(Collectors.toList());
3. Vlastný funkcionálny wrapper
Pre pokročilé projekty si môžeš vytvoriť generický wrapper, ktorý premení akúkoľvek metódu vyhadzujúcu výnimku na metódu kompatibilnú so Stream API.
Výnimky a výkon: stoja nás čas?
Často sa hovorí, že výnimky sú drahé. Ale čo to v praxi znamená? Najväčšiu réžiu pri vyvolaní výnimky nespôsobuje samotný objekt, ale naplnenie jeho stack trace. JVM musí v momente vytvorenia výnimky prejsť celý zásobník volaní a zaznamenať každú jednu metódu a riadok kódu.
Kedy na výkone záleží
Odpoveď závisí od toho, ako s výnimkami zaobchádzaš:
- Ak výnimky používaš správne (na výnimočné stavy), ich vplyv na výkon je zanedbateľný.
- Ak ich používaš nesprávne (napríklad na riadenie cyklu alebo validáciu každého jedného vstupu v high-frequency systéme), môžu tvoju aplikáciu významne spomaliť.
Práca so Stream API vyžaduje dobré znalosti ošetrovania chýb aj pochopenie toho, ako sa dáta v pamäti spracovávajú. Ak chceš svoje zručnosti posunúť ďalej, pozri si náš článok o Java Stream API, kde nájdeš komplexné príklady transformácie dát.
Best practices pre Java exception handling
Písanie try-catch blokov je jednoduché, ale ich správne navrhnutie vyžaduje disciplínu. Nasledujúce pravidlá by mali byť pevnou súčasťou tvojho programátorského arzenálu.
Buď maximálne špecifický
Nikdy nezachytávaj triedu Throwable alebo Exception, ak to nie je absolútne nevyhnutné (napríklad globálny error handler v najvyššej vrstve). Ak očakávaš chybu pri parsovaní čísla, zachyť NumberFormatException, nie všeobecnú chybu.
Loguj alebo vyhadzuj, nikdy nie oboje
Toto je jedna z najčastejších chýb. Ak výnimku zapíšeš do logu a následne ju znova vyhodíš (throw), v logoch sa objaví viackrát. To vytvára zbytočný neporiadok a sťažuje analýzu príčiny problému. Vyber si jednu cestu.
Zachovaj pôvodnú príčinu (exception chaining)
Ak zachytíš jednu výnimku a vyhodíš inú (napríklad technickú SQLException obalíš do biznisovej DataAccessException), vždy do konštruktora odovzdaj aj pôvodný objekt výnimky. Tým zachováš celý stack trace.
try {
// Nejaká operácia
} catch (SQLException e) {
// Pôvodná výnimka 'e' je odovzdaná ako príčina (cause)
throw new ServiceException("Chyba pri prístupe k údajom", e);
}
Prázdny catch blok je zlyhanie
Nikdy nenechávaj catch blok prázdny. Ak výnimku zachytíš a nič s ňou nespravíš, program bude pokračovať v nekonzistentnom stave a nebudeš mať ani tušenie, že sa niečo pokazilo. Ak máš úplnú istotu, že výnimku môžeš ignorovať, aspoň to jasne uveď v komentári.
Princíp fail-fast
Nečakaj, kým kód zlyhá hlboko v logike kvôli neplatnému vstupu. Validuj parametre na začiatku metódy a vyhoď výnimku okamžite. Ušetríš tým procesorový čas a zjednodušíš hľadanie chyby.
Anti-patterny, ktorým sa treba vyhnúť
Niektoré spôsoby použitia výnimiek sú v programátorskej komunite považované za vyslovené chyby v návrhu.
- Výnimky ako riadenie toku (control flow): nikdy nepoužívaj výnimky na vyskočenie z cyklu alebo podmienky. Výnimky majú slúžiť na výnimočné stavy, nie na bežnú logiku. Ich vytváranie je z hľadiska výkonu náročné kvôli generovaniu stack trace.
- Vracanie null namiesto výnimky: ak metóda nemôže splniť svoj účel, mala by vyhodiť výnimku alebo vrátiť Optional. Vrátenie null len prenáša problém na volajúceho, ktorý na to pravdepodobne zabudne a skončí s NullPointerException.
Prehľad najčastejších výnimiek v Jave
Nasledujúci zoznam najbežnejších výnimiek v Jave je zoradený od tých, s ktorými sa stretneš pravidelne, až po tie špecifickejšie. Veľká časť z nich vzniká pri práci s reťazcami (Java String) a s kolekciami (Java Collections Framework).
| Výnimka | Typ | Popis a typický scenár |
|---|---|---|
| NullPointerException | Unchecked | Nastane, keď sa pokúsiš zavolať metódu alebo pristúpiť k poľu objektu, ktorý má hodnotu null. |
| IllegalArgumentException | Unchecked | Používa sa pri validácii. Vyhodíš ju, keď metóda dostane parameter v nesprávnom formáte alebo rozsahu (napríklad záporný vek). |
| IndexOutOfBoundsException | Unchecked | Klasika pri práci s poliami alebo listami. Pokúšaš sa siahnuť na index, ktorý neexistuje (napríklad 5. prvok v 3-prvkovom liste). |
| IOException | Checked | Hlavný predstaviteľ kontrolovaných výnimiek. Nastane pri akomkoľvek zlyhaní vstupu alebo výstupu: chyba pri čítaní súboru, sieti alebo streamu. |
| NumberFormatException | Unchecked | Podtrieda IllegalArgumentException. Vzniká, keď sa snažíš prekonvertovať reťazec (String) na číslo, ale text neobsahuje platné číslice. |
| IllegalStateException | Unchecked | Signalizuje, že metóda bola zavolaná v nevhodnom čase. Napríklad sa snažíš konfigurovať objekt, ktorý už bol uzamknutý alebo spustený. |
| SQLException | Checked | Nočná mora pri práci s databázami. Zahŕňa všetko od chýb v SQL syntaxi až po problémy s pripojením k DB serveru. |
| UnsupportedOperationException | Unchecked | Často ju uvidíš pri práci s kolekciami. Napríklad ak sa pokúsiš pridať prvok do listu, ktorý bol vytvorený ako nemenný (immutable). |
| ClassCastException | Unchecked | Nastáva pri nesprávnom pretypovaní objektu na triedu, ktorej nie je inštanciou. V modernej Jave ju vďaka Generics uvidíš menej často. |
| ArithmeticException | Unchecked | Vyvolá ju JVM pri nepovolenej aritmetickej operácii, najčastejšie pri pokuse o celočíselné delenie nulou. |
FAQ: Často kladené otázky o Java exception handling
Kedy zvoliť checked a kedy unchecked výnimku?
Všeobecné pravidlo znie: použi kontrolovanú (checked) výnimku vtedy, ak očakávaš, že volajúci kód dokáže na danú situáciu rozumne reagovať. Nekontrolované (unchecked) výnimky používaj pre chyby v logike alebo stavy, z ktorých sa aplikácia za behu nevie spamätať. V mnohých moderných Java projektoch sa však čoraz častejšie používajú nekontrolované výnimky, aby sa predišlo zahlteniu kódu deklaráciami v signatúrach metód.
Aký je rozdiel medzi Throwable a Exception?
Throwable je najvyšší typ v hierarchii výnimiek a chýb, ktoré môže Java vyhodiť pomocou príkazu throw. Má dve podtriedy: Error pre kritické stavy JVM a Exception pre stavy, ktoré má riešiť aplikácia. V praxi teda pracuješ s Exception a jej potomkami, kým Throwable zachytávaš len úplne výnimočne, napríklad v poslednej záchytnej vrstve, ktorá má za úlohu zapísať dôvod pádu do logu.
Je pravda, že vyhadzovanie výnimiek drasticky spomaľuje kód?
Áno aj nie. Najväčšia časť nákladov pri výnimkách nesúvisí so samotným objektom, ale so získaním stack trace, ktorý sa vytvára pri ich vzniku. JVM musí prejsť celý zásobník volaní, čo stojí procesorový čas. Ak výnimky používaš na to, na čo sú určené, to znamená na výnimočné stavy, ich vplyv na výkon nepocítiš. Ak ich však zneužívaš na riadenie bežného toku programu, tvoja aplikácia sa môže výrazne spomaliť.
Ako správne logovať výnimky v produkčnom prostredí?
Zásadné pravidlo je logovať celú výnimku, nielen jej textovú správu. Používaj moderné logovacie knižnice (napríklad SLF4J s Logbackom) a odovzdaj objekt výnimky ako posledný parameter. Tým zabezpečíš, že v logoch uvidíš aj stack trace, bez ktorého je hľadanie príčiny v zložitej aplikácii takmer nemožné.
// Správny spôsob logovania s kontextom
try {
processData();
} catch (DataProcessingException e) {
logger.error("Nepodarilo sa spracovať údaje pre používateľa {}", userId, e);
}Ako získať stack trace výnimky ako text?
Niekedy potrebuješ stack trace uložiť do databázy alebo poslať v odpovedi API, nie iba vypísať do konzoly. Java na to nemá jednu hotovú metódu, stačí však presmerovať výpis do StringWriter:
StringWriter sw = new StringWriter();
e.printStackTrace(new PrintWriter(sw));
String stackTrace = sw.toString();
V projektoch, ktoré už používajú Apache Commons Lang, ten istý výsledok získaš cez ExceptionUtils.getStackTrace(e).Môžem vo vlastnej výnimke uchovávať citlivé údaje?
V žiadnom prípade. Do správy výnimky (message) nikdy nedávaj heslá, osobné údaje alebo bezpečnostné tokeny! Tieto správy často končia v logoch alebo sa vracajú klientovi cez API. Ak potrebuješ dodatočný kontext pre ladenie, ukladaj iba neškodné diagnostické údaje a zabezpeč, aby sa citlivé hodnoty nikdy nedostali do logov alebo odpovedí API.
Java exception handling: súčasť kvalitného kódu
Zvládnutie Java exception handling je cesta od písania kódu, ktorý je profesionálny a odolný. Výnimky nie sú zbytočná záťaž, práve naopak: sú dôležitým komunikačným kanálom medzi rôznymi vrstvami tvojho systému.
Pochopenie hierarchie, správne využívanie moderných konštrukcií ako try-with-resources a dodržiavanie best practices pri tvorbe vlastných výnimiek sú zručnosti, ktoré ťa odlíšia od začiatočníkov. Cieľom nie je zachytiť každú jednu chybu, ale vytvoriť predvídateľný systém, ktorý v prípade zlyhania poskytne dostatok informácií na rýchlu opravu.
Ak chceš svoje zručnosti v písaní kvalitného kódu rozvíjať ďalej, odporúčam ti naštudovať si princípy Clean Code. Vďaka nim sa naučíš, ako písať čistý kód tak, aby bol čitateľný a ľahko udržiavateľný pre teba aj tvojich kolegov. Ak hľadáš Java projekty, kde na kvalite kódu naozaj záleží, pozri si otvorené pozície v msg life Slovakia.
