Try-catch-finally y luego de nuevo un intento de captura

Question

menudo me he encontrado con situaciones como: -

try{ 
    ... 
    stmts 
    ... 
} 
catch(Exception ex) { 
    ... 
    stmts 
    ... 
} finally { 
    connection.close // throws an exception 
} 

que todavía necesita un try - catch dentro finalmente.

¿Cuál es la mejor práctica para superar esto?

Answer 1

Escriba una clase SQLUtils que contenga static closeQuietly métodos que capturen y registren dichas excepciones, luego utilícelas según corresponda.

que va a terminar con algo que dice así:

public class SQLUtils 
{ 
    private static Log log = LogFactory.getLog(SQLUtils.class); 

    public static void closeQuietly(Connection connection) 
    { 
    try 
    { 
     if (connection != null) 
     { 
     connection.close(); 
     } 
    } 
    catch (SQLExcetpion e) 
    { 
     log.error("An error occurred closing connection.", e); 
    } 
    } 

    public static void closeQuietly(Statement statement) 
    { 
    try 
    { 
     if (statement!= null) 
     { 
     statement.close(); 
     } 
    } 
    catch (SQLExcetpion e) 
    { 
     log.error("An error occurred closing statement.", e); 
    } 
    } 

    public static void closeQuietly(ResultSet resultSet) 
    { 
    try 
    { 
     if (resultSet!= null) 
     { 
     resultSet.close(); 
     } 
    } 
    catch (SQLExcetpion e) 
    { 
     log.error("An error occurred closing result set.", e); 
    } 
    } 
} 

Y su código de cliente será algo como:

Connection connection = null; 
Statement statement = null; 
ResultSet resultSet = null; 
try 
{ 
    connection = getConnection(); 
    statement = connection.prepareStatement(...); 
    resultSet = statement.executeQuery(); 

    ... 
} 
finally 
{ 
    SQLUtils.closeQuietly(resultSet); 
    SQLUtils.closeQuietly(statment); 
    SQLUtils.closeQuietly(connection); 
} 

Answer 2

por lo general lo hice de esta manera:

try { 
    try { 
     .. 
     stmts 
     ... 
    } 
    finally { 
     connection.close(): 
    } 
} catch (Exception ex) { 
    .. 
    stmts 
    ..  
} 

por lo general sólo se utiliza esto cuando no estaba usando una biblioteca que se hizo cargo de esta instalación de cañerías para mí.

Como Imagist señala, esto no es técnicamente el mismo que finalmente se ejecutará antes de la captura, pero creo que resuelve el problema que estabas tratando de resolver.

Answer 3

No dude en uso un intento más ... atrapa el interior finalmente

Answer 4

sólo recuerda .. finalmente siempre consigue ejecutar ya sea con o intento de captura ..

Answer 5

En general, usted no quiere hacer nada más que ingrese una excepción que se produce cuando se cierra un recurso, por lo que realmente debe ir en su propio try/catch. Sin embargo, este es un código genérico que sucederá a menudo, por lo que Do not Repeat Yourself, y ponga el cierre en un método estático (como sugiere Nick Holt) de esa manera no tendrá los dos elementos try/catch en el mismo método, haciendo que el código sea más fácil de leer y seguir.

Answer 6

Commons-io también tiene closeQuietly() para las transmisiones de entrada y salida. Lo estoy usando todo el tiempo. Hace que tu código sea mucho más legible.

Answer 7

Como han mencionado otros, una utilidad estática closeQuietly es el camino a seguir. Una cosa a añadir - si usted está en el mundo de la java.io en lugar de java.sql entonces hay una interfaz útil precisamente para este propósito - java.io.Closeable

Todas las fuentes de datos y los sumideros en java.io implementan esta interfaz - todos los arroyos, canales, escritores y lectores De esta forma, puede crear una sola utilidad para hacer frente al mismo problema de "excepción al cerrar()" sin requerir muchas versiones sobrecargadas.

p. Ej.

public class IoUtils { 

    public static closeQuietly (Closeable closeable) { 
    try { 
     closeable.close(); 
    } catch (IOException logAndContinue) { 
     ... 
    } 
    } 

} 

Answer 8

También hay método práctico Closeables # closeQuitely en la biblioteca de Google Guava - que puede ser utilizado para cualquier closeable

Answer 9

¿Podemos tener un bloque try seguido por fin Bock y captura cuadra después de eso?

Answer 10

Sólo una nota rápida para decir que con Java 7 (y 8), en su lugar puede escribir:

public void java7() throws SQLException { 
    try (Connection connection = Connections.openConnection(); 
     CallableStatement callableStatement = connection.prepareCall("my_call"); 
     ResultSet resultSet = callableStatement.executeQuery()) { 

     while (resultSet.next()) { 
      String value = resultSet.getString(1); 
      System.out.println(value); 
     } 
    } 
} 

en lugar de la versión Java 6, que tiene todas estas líneas:

public void java6() throws SQLException { 
    Connection connection = Connections.openConnection(); 
    try { 
     CallableStatement callableStatement = connection.prepareCall("my_call"); 
     try { 
      ResultSet resultSet = callableStatement.executeQuery(); 
      try { 
       while (resultSet.next()) { 
        String value = resultSet.getString(1); 
        System.out.println(value); 
       } 
      } finally { 
       try { 
        resultSet.close(); 
       } catch (Exception ignored) { 
       } 
      } 
     } finally { 
      try { 
       callableStatement.close(); 
      } catch (Exception ignored) { 
      } 
     } 
    } finally { 
     try { 
      connection.close(); 
     } catch (Exception ignored) { 
     } 
    } 
}