Exception handling in java

50 %
50 %
Information about Exception handling in java

Published on February 25, 2014

Author: pr80ik

Source: slideshare.net


Best practices on how to work with exceptions in Java

Exception handling in java

What is Exception  An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions.

Try catch finally try { //do something } catch (ExceptionType name) { } catch (ExceptionType name) { } finally { //clean up }

Advantages  Separating Error-Handling Code from "Regular" Code  Propagating Errors Up the Call Stack  Grouping and Differentiating Error Types

Exception Type Hierarchy

Checked exceptions  Part of the method signature  Compile type checking  Requires programmer to handle the exception or declare the method as throws exception  Unique to java  e.g. FileNotFoundException

Unchecked exceptions  No need to declare the exception in method’s signature  No compile time checking  Usually indicate programming error  e.g. NullPointerException

Error  Indicate error in the underlying JVM  Error are external to the application  Application does not usually have to deal with these class of Exceptions  e.g. OutOfMemoryError

When to throw exceptions  Exceptions indicate a broken contract  Precondition (e.g. file is open for read)  Postcondition (e.g. read a character from file)  Your method encounters an abnormal condition that it can't handle  If your method is unable to fulfill its contract, throw either a checked or unchecked exception.

What to throw?  Exceptions v/s Errors  Errors are for JVM  Exceptions for rest of us  Checked v/s Unchecked exceptions  Can caller recover from this error?  Yes: checked  No: unchecked

When to catch exception 1. When you can handle the exception 2. When you need to throw a different type of exception 3. Refer to 1 & 2

When not to throw an exception  To achieve Flow control using exception try { } while (true) { increaseCount(); } } catch (MaximumCountReachedException ex) { } //Continue execution public void increaseCount() throws MaximumCountReachedException { if (count >= 5000) throw new MaximumCountReachedException(); }

3 rules  What went wrong?  Where did it go wrong?  Why did it go wrong?  If your exception does not provide answers to all these questions, you are doing something wrong!

Performance implications of exceptions  Exceptions are expensive for the JVM  Creating stack traces requires resources and CPU  the Java VM requires more efforts to handle a thrown exception than a normal method

Anti Patterns          Log and Throw Throwing Generic Exception Catching Generic Exception Destructive Wrapping Log and Return Null Catch and Ignore (a.k.a. Head in the Sand) Throw from Within Finally Multi-Line Log Messages Unsupported Operation Returning Null

Anti Patterns - Log and Throw  Log the error and throw the same exception again  Messy log file  Achieves nothing

Anti Patterns - Throwing Generic Exception  The caller does not know the nature of error – hinders error handling

Anti Patterns - Catching Generic Exception  We are masking programming errors

public SomeInterface buildInstance(String className) { SomeInterface impl = null; try { Class clazz = Class.forName(className); impl = (SomeInterface)clazz.newInstance(); } catch (Exception e) { log.error("Error creating class: " + className); } return impl; }

Anti Patterns - Destructive Wrapping catch (NoSuchMethodException e) { throw new MyServiceException("Blah: "+ e.getMessage()); }

Anti Patterns - Log and Return Null catch (NoSuchMethodException e) { LOG.error("Blah", e); return null; }

Anti Patterns - Catch and Ignore (a.k.a. Head in the Sand) catch (NoSuchMethodException e) { }

Anti Patterns - Throw from Within Finally try { blah(); } finally { cleanUp(); }

Anti Patterns - Multi-Line Log Messages LOG.debug("Using cache policy A"); LOG.debug("Using retry policy B");

Anti Patterns - Unsupported Operation Returning Null public String foo() { // Not supported in this implementation. return null; }  Throw UnsupportedOperationException

Best practices  Throw checked exception when caller can recover from error  Throw runtime exception when the caller cannot recover  Throw runtime exception for programming error  Throw early, catch late  Use NestedException  Don’t catch an exception if you cant do any thing about it.  Log exception only once, and at the latest possible time  Default Error Page in presentation layer for all Runtime Exceptions

Exception chaining try{ ..some code that throws XXXException }catch(XXXException ex){ throw new RuntimeException(ex); }

Exception logging  Log all internal states  Log all parameters to the method that failed  Log all data required to trace the error  Ensure log statements don’t cause NPE*

Exceptions in a typical enterprise applications  Define a hierarchy of exceptions.  Lower level module throws lower level exceptions, higher level module encapsulate lower level exceptions  Define which exceptions will cause transaction to rollback

Exceptions and Transactions  @ApplicationException(rollback=true) public class FooException extends Exception ...


references Best practices in EJB exception handling http://www.ibm.com/developerworks/library/j-ejbexcept.html Beware the dangers of generic Exceptions http://www.javaworld.com/javaworld/jw-10-2003/jw-1003generics.html Exception Handling in Web Applications http://weblogs.java.net/blog/crazybob/archive/2004/02/exception_han dl.html Designing with Exceptions http://www.artima.com/designtechniques/desexceptP.html Build a better exception-handling framework http://www.ibm.com/developerworks/java/library/j-ejb01283.html

References (cont…) JAVA EXCEPTIONS http://www.javaolympus.com/J2SE/Exceptions/JavaExceptions.jsp Exception-Handling Antipatterns http://today.java.net/pub/a/today/2006/04/06/exception-handling-antipatterns.html Three Rules for Effective Exception Handling http://today.java.net/pub/a/today/2003/12/04/exceptions.html 13 Exceptional Exception Handling Techniques http://www.manageability.org/blog/stuff/exceptional-exception-handling-techniques Best Practices for Exception Handling http://www.onjava.com/pub/a/onjava/2003/11/19/exceptions.html Lesson: Exceptions http://java.sun.com/docs/books/tutorial/essential/exceptions/index.html

Add a comment

Related presentations

Related pages

Exception Handling - java-tutorial.org

In diesem wichtigen Kapitel unseres Java-Tutorials geht es um das Exception Handling (Ausnahmebehandlung).
Read more

Exception Handling in Java - javatpoint

Exception Handling in Java with checked, unchecked and errors with example and usage of try, catch, throw, throws and finally keywords.
Read more

Ausnahmebehandlung – Wikipedia

Bei Java gibt es als Weiterentwicklung der Ausnahme die „Checked Exception“ (dt. etwa: überprüfte Ausnahme). ... (Structured Exception Handling)
Read more

Lesson: Exceptions (The Java™ Tutorials > Essential Classes)

This Java tutorial describes exceptions, basic input/output, concurrency, regular expressions, and the platform environment
Read more

Java - Exceptions - Tutorialspoint

Java - Exceptions; Java ... Based on these we have three categories of Exceptions you need to understand them to know how exception handling works in Java,
Read more

Java Exception Handling - Jenkov.com

This tutorial series explains various aspects, tips and tricks of Java exception handling including exception hierarchies, checked and unchecked exceptions ...
Read more

Java Exception Handling Tutorial with Examples and Best ...

29 Responses to "Java Exception Handling Tutorial with Examples and Best Practices" Mohammed says: September 29, 2015 at 3:20 pm. Thanks a lot.
Read more

Catching and Handling Exceptions (The Java™ Tutorials ...

This Java tutorial describes exceptions, basic input/output, concurrency, regular expressions, and the platform environment
Read more

Exception handling - Wikipedia, the free encyclopedia

Exception handling is the process of responding to the occurrence, during computation, of exceptions – anomalous or exceptional conditions requiring ...
Read more

Rheinwerk Computing :: Java ist auch eine Insel – 6 Exceptions

Java ist auch eine Insel von Christian Ullenboom Das umfassende Handbuch: Java ist auch eine Insel geb., mit DVD 1482 S., 49,90 Euro Rheinwerk Computing
Read more