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 ..