java - lesion - jj watt wife

Try-catch-finally y luego de nuevo un try catch

Question

A menudo me he encontrado con situaciones como:

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

que todavía necesita una prueba, atrapa el bloque adentro, finalmente.

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

Answer 1

¿Podemos tener un bloque de prueba seguido de un bloque de bock y catch más tarde para eso?

Answer 2

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

Answer 3

Como otros han mencionado, una utilidad estática de closeQuietly es el camino a seguir. Una cosa para agregar: si se encuentra en el mundo de java.io lugar de java.sql , existe una interfaz útil para este propósito: java.io.Closeable

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

p.ej

public class IoUtils {

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

}

Answer 4

En general, no desea hacer nada más que registrar una excepción, que ocurre cuando se cierra un recurso, por lo que realmente debería ir en su propio intento / captura. 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 5

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

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 6

No dudes en utilizar un intento más ... atrapar el interior finalmente.

Answer 7

Normalmente lo hice de esta manera:

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

Normalmente solía usar esto cuando no estaba usando una biblioteca que se encargó de esta fontanería.

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

Answer 8

Solo una nota rápida para decir que con Java 7 (y 8), 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 de 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) {
        }
    }
}

Answer 9

También hay un práctico método Closeables # closeQuitely en la biblioteca de Google Guava, se puede usar para cualquier cierre

Answer 10

solo recuerda .. finalmente, siempre ejecuta ejecutar con try o catch ..