¿Cómo hacer que el código se ejecute solo si se lanzó una excepción?

Question

Tengo una oportunidad con varias capturas diferentes después. Tengo un código de "limpieza" que solo debe ejecutarse si se lanza una excepción. Podría agregar el mismo código a cada excepción, pero eso se convierte en una pesadilla de mantenimiento. Básicamente, me gustaría algo como la declaración final, pero para que solo se ejecute si se lanzó una excepción.

¿Esto es posible?

Answer 1

Desafortunadamente, no hay soporte directo para esto. ¿Qué tal algo como esto

boolean successful = false; 
try { 
    // do stuff 
    successful = true; 
} catch (...) { 
    ... 
} finally { 
    if (!successful) { 
     // cleanup 
    } 
} 

Answer 2

Lo único que puedo pensar es establecer una variable en cada captura y para verificar si esa variable en fin.

Pseudocódigo:

Boolean caught = false; 

try { 

    //risky code here 

catch(err) { 
    caught = true; 
    // Do other stuff 
} 
catch(err) { 
    caught = true; 
    // Do other stuff 
} 
catch(err) { 
    caught = true; 
    // Do other stuff 
} 
finally { 
    if (caught) { 
     // Do clean up 
    } 

} 

Answer 3

¿Por qué no sólo tiene que utilizar sencilla intento de captura &?

try 
{ 
    foo(); 
} 
catch(Exception1 e1) 
{ 
    dealWithError(1); 
} 
catch(Exception2 e2) 
{ 
    dealWithError(2); 
} 
catch(Exception3 e3) 
{ 
    dealWithError(3); 
} 

... 

private void dealWithError(int i) 
{ 
    if(i == 1) // deal with Exception1 
    else if(i == 2) // deal with Exception2 
    else if(i == 3) // deal with Exception3 
} 

Answer 4

podría añadir el mismo código para cada una excepción, sino que se convierte en una pesadilla de mantenimiento.

O si borrar el 'excepción':

podría añadir el mismo código para cada [lugar], pero que se convierte en una pesadilla de mantenimiento.

Esto es para lo que están hechos los métodos.

private void cleanup() { /* clean up */ } 

... 

try { 
    // oh noes 

} catch (MyException me) { 
    cleanup(); 
} catch (AnotherException ae) { 
    cleanup(); 
} 

Maintenance hassle gone!

Answer 5

Usted podría tratar de envolver dos capas de controladores de excepciones, y volver a lanzar la excepción después de haber hecho un tratamiento común:

try { 
     try { 
      // your code goes here 

     } catch (Throwable t) { 
      // do common exception handling for any exception 
      throw t; 
     }  

    } catch (NullPointerException nx) { 
     // handle NPE 
    } catch (Throwable t) { 
     // handle any other exception 
    } 

No estoy seguro de que realmente me gusta esta solución, aunque ... se siente como un poco de una cortar. Probablemente preferiría ver la excepción manejada explícitamente en cada instancia, incluso si esto significa repetir una llamada a algún tipo de función de limpieza compartida.