Rethrow Exception Real Application

Question

In Java 7 Rethrow Exception feature added.I know it's concept but I want to see the real application of it and why this feature needed?

Answer 1

I will take examples from here This is the example:

  static class FirstException extends Exception { }
  static class SecondException extends Exception { }

  public void rethrowException(String exceptionName) throws FirstException, SecondException {
    try {
      if (exceptionName.equals("First")) {
        throw new FirstException();
      } else {
        throw new SecondException();
      }
    } catch (FirstException e) {
      throw e;
    }catch (SecondException e) {
      throw e;
    }
  }

This compiles with both java 6 an 7.

If you want to keep checked exceptions from method signature, you have to keep cumbersome catch clauses in java 6.

In Java 7 you can do it in following way:

public void rethrowException(String exceptionName) throws FirstException, SecondException {
  try {
    if (exceptionName.equals("First")) {
      throw new FirstException();
    } else {
      throw new SecondException();
    }
  } catch (Exception e) {
    throw e;
}

So your benefit is that you have less cumbersome catch clause.

Answer 2

Use Rethrowing Exceptions with More Inclusive Type Checking feature

in Java SE 7, you can specify the exception types FirstException and SecondException in the throws clause in the rethrowException method declaration

When you want to declare specific exceptions that can be thrown (mainly when you are catching a generic error)

For example see Precise Rethrow example:

public static void precise() throws ParseException, IOException{
    try {
        new SimpleDateFormat("yyyyMMdd").parse("foo");
        new FileReader("file.txt").read();
    } catch (Exception e) {
        System.out.println("Caught exception: " + e.getMessage());
        throw e;
    }
}

This also make your code compliant to Sonar's Raw Exception rule.

Note you can similarly catch Throwable

Answer 3

Couple of use-cases:

1. Using rethrow, you can edit the stacktrace information to make it more accurate. Also when needed you can hide or rid off the unnecessary internal details in stack trace.

   try     { //... }
   catch (Exception e) { throw (Exception) e.fillInStackTrace(); }
   

   Real application of fillInStackTrace is very well explained here: Why is Throwable.fillInStackTrace() method public? Why would someone use it?

   Quote from the book "Thinking in Java" written by Bruce Eckel:

   If you want to install new stack trace information, you can do so by calling fillInStackTrace( ), which returns a Throwable object that it creates by stuffing the current stack information into the old exception object

2. Add custom message to the thrown exception. Add custom message to thrown exception while maintaining stack trace in Java

A simple example I can think of:

void fileOperator(String operationType) throws Exception(){ ... }

void fileReader() throws Exception {
    try{
        fileOperator('r');
    }
    catch(Exception e){
        throw Exception("Failed to read the file", e);
    }
}

void fileWriter() throws Exception{
    try{
        fileOperator('w');
    }
    catch(Exception e){
        throw Exception("Failed to write the file", e);
    }
}

Also, we can throw a more specific exception type (say FileReadException, FileWriteException) from the catch block.