Java Global Exception Handler

1. Overzicht

In deze tutorial zullen we ons concentreren op de Global Exception Handler in Java. We bespreken eerst de basisprincipes van de uitzonderingen en de afhandeling van uitzonderingen. Daarna zullen we de globale exception handler uitgebreid bekijken.

Raadpleeg Afhandeling van uitzonderingen in Java voor meer informatie over de uitzonderingen in het algemeen.

2. Wat is een uitzondering?

Een uitzondering is een abnormale toestand die optreedt in een codereeks tijdens runtime of tijdens compilatie. Deze abnormale toestand doet zich voor wanneer een programma de semantische beperkingen van de programmeertaal Java schendt.

Uitzonderingen die optreden tijdens het compileren zijn gecontroleerde uitzonderingen. Deze uitzonderingen zijn directe subklassen van de Uitzondering class, en het is noodzakelijk om deze uitzonderingen in de code af te handelen.

Een ander soort uitzonderingen zijn de ongecontroleerde uitzonderingen. De compiler controleert deze uitzonderingen niet tijdens het compileren. Deze uitzonderingen zijn directe subklassen van de RuntimeException klasse die de extensie Uitzondering klasse.

Het is ook niet nodig om runtime-uitzonderingen in de code af te handelen.

3. Uitzonderingshandlers

Java is een robuuste programmeertaal. Een van de belangrijkste kenmerken die het robuust maken, is het raamwerk voor het afhandelen van uitzonderingen. Het betekent dat het programma netjes kan worden afgesloten op het moment van een fout, in plaats van alleen maar te crashen.

Elke keer dat er een uitzondering optreedt, wordt een E.xception object is geconstrueerd, hetzij door de JVM, hetzij door de methode die de code uitvoert. Dit object bevat de informatie over de uitzondering. Afhandeling van uitzonderingen is een manier om hiermee om te gaan Uitzondering voorwerp.

3.1. De proberen te vangen Blok

In het volgende voorbeeld is het proberen block bevat de code die een uitzondering kan genereren. De vangst block bevat de logica om deze uitzondering af te handelen.

De vangst blok vangt het Uitzondering object dat de code in het proberen blok verhoogt:

String string = "01,, 2010"; DateFormat-indeling = nieuwe SimpleDateFormat ("MM, dd, jjjj"); Datum datum; probeer {date = format.parse (string); } catch (ParseException e) {System.out.println ("ParseException gevangen!"); }

3.2. De werpen en gooit Sleutelwoorden

Als alternatief kan de methode er ook voor kiezen om de uitzondering te genereren in plaats van deze af te handelen. Dat betekent de logica om de Uitzondering object is ergens anders geschreven.

Gewoonlijk verwerkt de aanroepende methode de uitzondering in dergelijke gevallen:

openbare klasse ExceptionHandler {openbare statische leegte main (String [] args) {String strDate = "01, 2010"; String dateFormat = "MM, dd, jjjj"; probeer {Date date = new DateParser (). getParsedDate (strDate, dateFormat); } catch (ParseException e) {System.out.println ("De aanroepende methode heeft ParseException gevangen!"); }}} class DateParser {public Date getParsedDate (String strDate, String dateFormat) genereert ParseException {DateFormat format = new SimpleDateFormat (dateFormat); probeer {return format.parse (strDate); } catch (ParseException parseException) {throw parseException; }}}

Vervolgens zullen we de Global Exception Handler beschouwen als een algemene manier om uitzonderingen af ​​te handelen.

4. Globale handler voor uitzonderingen

De instanties van de RuntimeException zijn optioneel te hanteren. Bijgevolg laat het nog steeds een venster open voor het verkrijgen van de lange stack-traces tijdens runtime. Om dit aan te pakken, Java biedt het UncaughtExceptionHandler koppel. De Draad klasse bevat dit als een innerlijke klasse.

Naast deze interface, Java 1.5-release introduceerde ook een statische methode setDefaultUncaughtExceptionHandler () in de Draad klasse. Het argument van deze methode is een handlerklasse die de UncaughtExceptionHandler koppel.

Bovendien verklaart deze interface de methode uncaughtException (Thread t, Throwable e). Het wordt aangeroepen wanneer een bepaalde thread t wordt beëindigd vanwege de opgegeven niet-afgevangen uitzondering e. De implementerende klasse implementeert deze methode en definieert de logica voor het omgaan met deze niet-afgevangen uitzonderingen.

Laten we eens kijken naar het volgende voorbeeld dat een ArithmeticException tijdens runtime. We definiëren de klasse Handler dat implementeert de interface UncaughtExceptionHandler.

Deze klasse implementeert de methode uncaughtException () en definieert logica om niet-afgevangen uitzonderingen erin af te handelen:

openbare klasse GlobalExceptionHandler {openbare statische leegte hoofd (String [] args) {Handler globalExceptionHandler = nieuwe Handler (); Thread.setDefaultUncaughtExceptionHandler (globalExceptionHandler); nieuwe GlobalExceptionHandler (). performArithmeticOperation (10, 0); } openbare int performArithmeticOperation (int num1, int num2) {return num1 / num2; }} class Handler implementeert Thread.UncaughtExceptionHandler {privé statische logger LOGGER = LoggerFactory.getLogger (Handler.class); public void uncaughtException (Thread t, Throwable e) {LOGGER.info ("Onverwerkte uitzondering betrapt!"); }}

Hier is de momenteel uitgevoerde thread de hoofdthread. De instantie wordt dus doorgegeven aan de methode uncaughtException () samen met de opgeworpen uitzondering. De klas Handler behandelt vervolgens deze uitzondering.

Hetzelfde geldt voor niet-verwerkte gecontroleerde uitzonderingen. Laten we hiervan ook een snel voorbeeld bekijken:

public static void main (String [] args) gooit Uitzondering {Handler globalExceptionHandler = nieuwe Handler (); Thread.setDefaultUncaughtExceptionHandler (globalExceptionHandler); Padbestand = Paths.get (""); Files.delete (bestand); }

Hier de Files.delete () methode gooit een gecontroleerd IOException, die verder wordt gegooid door de hoofd() methode handtekening. De Handler zal deze uitzondering ook opvangen.

Op deze manier kan het UncaughtExceptionHandler helpt bij het beheren van niet-verwerkte uitzonderingen tijdens runtime. Het breekt het idee van het opvangen en afhandelen van de uitzondering dichtbij het punt van oorsprong.

5. Conclusie

In dit artikel hebben we de tijd genomen om te begrijpen wat de uitzonderingen zijn en wat de basismanieren zijn om hiermee om te gaan. We hebben ook vastgesteld dat de globale uitzonderingshandler deel uitmaakt van de Draad class en het behandelt de niet-afgevangen runtime-uitzonderingen.

Toen zagen we een voorbeeldprogramma dat een runtime-uitzondering genereert en deze afhandelt met behulp van een globale uitzonderingshandler.

De voorbeeldcodes voor dit artikel zijn te vinden op GitHub.