lance l'exception dans les blocs finaux

Question

Existe-t-il une manière élégante de traiter les exceptions qui sont lancées dans finally bloc ?

Par exemple :

try {
  // Use the resource.
}
catch( Exception ex ) {
  // Problem with the resource.
}
finally {
   try{
     resource.close();
   }
   catch( Exception ex ) {
     // Could not close the resource?
   }
}

Comment éviter le try / catch dans le finally bloc ?

Answer 1

Je fais généralement comme ça :

try {
  // Use the resource.
} catch( Exception ex ) {
  // Problem with the resource.
} finally {
  // Put away the resource.
  closeQuietly( resource );
}

Ailleurs :

protected void closeQuietly( Resource resource ) {
  try {
    if (resource != null) {
      resource.close();
    }
  } catch( Exception ex ) {
    log( "Exception during Resource.close()", ex );
  }
}

Answer 2

J'utilise généralement l'un des closeQuietly méthodes en org.apache.commons.io.IOUtils :

public static void closeQuietly(OutputStream output) {
    try {
        if (output != null) {
            output.close();
        }
    } catch (IOException ioe) {
        // ignore
    }
}

Answer 3

Si vous utilisez Java 7, et resource met en œuvre AutoClosable vous pouvez le faire (en utilisant InputStream comme exemple) :

try (InputStream resource = getInputStream()) {
  // Use the resource.
}
catch( Exception ex ) {
  // Problem with the resource.
}

Answer 4

On peut dire que c'est un peu exagéré, mais c'est peut-être utile si vous laissez les exceptions s'accumuler et que vous ne pouvez rien consigner à l'intérieur de votre méthode (par exemple, parce que c'est une bibliothèque et que vous préférez laisser le code appelant gérer les exceptions et la consignation) :

Resource resource = null;
boolean isSuccess = false;
try {
    resource = Resource.create();
    resource.use();
    // Following line will only run if nothing above threw an exception.
    isSuccess = true;
} finally {
    if (resource != null) {
        if (isSuccess) {
            // let close throw the exception so it isn't swallowed.
            resource.close();
        } else {
            try {
                resource.close();
            } catch (ResourceException ignore) {
                // Just swallow this one because you don't want it 
                // to replace the one that came first (thrown above).
            }
        }
    }
}

MISE À JOUR : J'ai examiné cette question un peu plus en détail et j'ai trouvé un excellent article sur le blog de quelqu'un qui a manifestement réfléchi à cette question plus que moi : http://illegalargumentexception.blogspot.com/2008/10/java-how-not-to-make-mess-of-stream.html Il va plus loin et combine les deux exceptions en une seule, ce qui pourrait être utile dans certains cas.

Answer 5

Une solution, si les deux Exceptions sont deux classes différentes

try {
    ...
    }
catch(package1.Exception err)
   {
    ...
   }
catch(package2.Exception err)
   {
   ...
   }
finally
  {
  }

Mais parfois, vous ne pouvez pas éviter ce deuxième try-catch, par exemple pour fermer un flux.

InputStream in=null;
try
 {
 in= new FileInputStream("File.txt");
 (..)// do something that might throw an exception during the analysis of the file, e.g. a SQL error
 }
catch(SQLException err)
 {
 //handle exception
 }
finally
 {
 //at the end, we close the file
 if(in!=null) try { in.close();} catch(IOException err) { /* ignore */ }
 }