Page History

Methods invoked from within a finally block can throw an exception. Failing Failure to catch and handle such exceptions results in the abrupt termination of the entire try block. This Abrupt termination causes any exception thrown in the try block to be forgottenlost, preventing any possible recovery method from handling that specific problem. Additionally, the transfer of control associated with the exception may prevent execution of any expressions or statement statements that occurs occur after the point in the finally block from which the exception is thrown. Consequently, programs must appropriately handle checked exceptions appropriately that are thrown from within a finally block.

Allowing checked exceptions to escape a finally block also violates ERR04-J. Do not complete abruptly from a finally block.

Noncompliant Code Example

This noncompliant code example contains a finally block that closes the reader object. The programmer incorrectly assumes that the statements in the finally block cannot throw exceptions , and consequently fails to appropriately handle the any exception appropriatelythat may arise.

public class Operation {
  privatepublic static void doOperation(String some_file) throws IOException {
    BufferedReader reader = null; {
    // ... Code to check or set character encoding ...
    try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      // Do operations 
try {
       } finally// {
Do operations 
    if (reader !=} null)finally {
        reader.close();
      }
      // ... Other clean-upcleanup code ...
    }
  }

   public static} voidcatch main(String[]IOException argsx) throws{
 IOException {
    String// pathForward = "somepath";to handler
    doOperation(path);}
  }
}

The close() method can throw an IOException, which, if thrown, would prevent execution of any subsequent clean-up cleanup statements. The compiler This problem will not diagnose this problem because the doOperation() method explicitly declares that it may throw IOExceptionbe diagnosed by the compiler because any IOException would be caught by the outer catch block. Also, an exception thrown from the close() operation can mask any exception that gets thrown during execution of the Do operations block, preventing proper recovery.

Compliant Solution (Handle Exceptions in finally Block)

This compliant solution encloses the close() method invocation in a try-catch block of its own within the finally block. Consequently, an the potential IOException can be handled without permitting allowing it to propagate fartherfurther.

public class Operation {
  public static void doOperation(String some_file) {
 throws  IOException {
    BufferedReader reader = null;

// ... Code to check or set character encoding ...
    try {
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file));
      // Do operations
    } finally {
try {
        if// (readerDo != null) {operations 
      } finally try {    
          // Enclose in try-catch block{
          reader.close();
        } catch (IOException ie) {
          // Forward to handler
        }
      }
      // Other clean-up code
    }
  }

  public static void main(String[] args) throws IOException {
    String path = "somepath";
    doOperation(path);
  }
}

...

.

...

.

...

Compliant Solution (Dedicated Method to Handle Exceptions)

...

.

...

public class Operation {
  static void doOperation(String some_file) throws IOException {
    BufferedReader reader = null;

    try {
      reader = new BufferedReader(new FileReader(some_file));
      // Do operations
    } finally {
      closeHandlingException(reader);
      // Other clean-up code Other cleanup code ...
    }
  } 

  private static void closeHandlingException(BufferredReader s) {
    if (s != null) {
      try {
        s.close();
      } catch (IOException iex) {
        // Forward to handler
      }
    }
  }

  public static void main(String[] args) throws IOException {
    doOperation("somepath");
  }
}

Compliant Solution (

...

try-with-resources)

Java 1.SE 7 provides introduced a new feature , called try-with-resources, that  that can close certain resources automatically should in the event of an error occur. This compliant solution uses try-with-resources to properly close the file.

public class Operation {
  public static void doOperation(String some_file) {
    // ... Code to check or set character encoding ...
    try ( // try-with-resources
      BufferedReader reader =
          new BufferedReader(new FileReader(some_file))) {
      // Do operations
    } catch (IOException ex) {
      System.err.println("thrown exception: " + ex.toString());
      Throwable[] suppressed = ex.getSuppressed();
      for (int i = 0; i < suppressed.length; i++) {
        System.err.println("suppressed exception: " 
            + suppressed[i].toString());
      }
      // HandleForward to exceptionhandler
    }
  }

  public static void main(String[] args) {
    if (args.length < 1) {
      System.out.println("Please supply a path as an argument");
      return;
    }
    doOperation(args[0]);
  }
}

If When an IOException occurs in the try block of the doOperation() method, it will be is caught by the catch block and be printed as the thrown exception. This includes any error while doing operations as well as any error incurred while Exceptions that occur while creating the BufferedReader are included. If When an IOException occurs while closing the reader, that error will exception is also be caught by the catch block and be printed as the thrown exception. If IOException}}s occur in both the try block and while closing the {{reader throw an IOException, the catch clause still catches both , exceptions and prints the try- block error exception as the thrown exception. The close error exception is suppressed and printed as the suppressed exception. In all cases, the reader is safely closed.For this program not to violate ERR00-J. Do not suppress or ignore checked exceptions, appropriate error handling must be added.

Risk Assessment

Failure to handle an exception in a finally block can lead to may have unexpected results.

Automated Detection

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

Bibliography

\[[Bloch 2005|AA. Bibliography#Bloch 05]\] Puzzle 41: Field and Stream
\[[Chess 2007|AA. Bibliography#Chess 07]\] 8.3 Preventing Resource Leaks (Java)
\[[Harold 1999|AA. Bibliography#Harold 99]\]
\[[J2SE 2011|AA. Bibliography#J2SE 11]\] The try-with-resources Statement

Related Guidelines

Bibliography

...

Image Added Image Added Image AddedERR04-J. Do not exit abruptly from a finally block      06. Exceptional Behavior (ERR)      ERR06-J. Do not allow exceptions to expose sensitive information