Exception handling 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 ...

Questions

referencesBest practices in EJB exception handlinghttp://www.ibm.com/developerworks/library/j-ejbexcept.html

Beware the dangers of generic Exceptionshttp://www.javaworld.com/javaworld/jw-10-2003/jw-1003-

generics.html

Exception Handling in Web Applicationshttp://weblogs.java.net/blog/crazybob/archive/2004/02/

exception_handl.html

Designing with Exceptionshttp://www.artima.com/designtechniques/desexceptP.html

Build a better exception-handling frameworkhttp://www.ibm.com/developerworks/java/library/j-

ejb01283.html

References (cont…)JAVA EXCEPTIONS http://www.javaolympus.com/J2SE/Exceptions/JavaExceptions.jsp

Exception-Handling Antipatternshttp://today.java.net/pub/a/today/2006/04/06/exception-handling-

antipatterns.html

Three Rules for Effective Exception Handlinghttp://today.java.net/pub/a/today/2003/12/04/exceptions.html

13 Exceptional Exception Handling Techniqueshttp://www.manageability.org/blog/stuff/exceptional-exception-handling-

techniques

Best Practices for Exception Handlinghttp://www.onjava.com/pub/a/onjava/2003/11/19/exceptions.html

Lesson: Exceptionshttp://java.sun.com/docs/books/tutorial/essential/exceptions/index.html