Ejecutando dos Java PreparedStatements con una opción de estilo de conexión

Question

Bien, me he dado cuenta de que realmente he formulado demasiadas preguntas sin haber contribuido a la comunidad, pero quiero su opinión al respecto. Decir si tengo

private void closeAll(ResultSet rs, PreparedStatement ps, Connection con) { 
    if (rs != null) 
     try { 
      rs.close(); 
     } catch (SQLException e) { 
     } 
    if (ps != null) 
     try { 
      ps.close(); 
     } catch (SQLException e) { 
     } 
    if (con != null) 
     try { 
      con.close(); 
     } catch (SQLException e) { 
     } 
} 

y que quería hacer varias operaciones en mi base de datos MySQL utilizando una sola conexión. ¿Es mejor escribir

Connection con = ...; 
PreparedStatement ps = null; 
ResultSet rs = null; 
try { 
    ps = con.prepareStatement(...); 
    rs = ps.executeQuery(); 
    if (rs.next()) ...; 
} catch (SQLException e) { 
    System.err.println("Error: " + e); 
} finally { 
    closeAll(rs, ps, null); 
} 
try { 
    ps = con.prepareStatement(...); 
    rs = ps.executeQuery(); 
    if (rs.next()) ...; 
} catch (SQLException e) { 
    System.err.println("Error: " + e); 
} finally { 
    closeAll(rs, ps, con); 
} 

o

Connection con = ...; 
PreparedStatement ps = null; 
ResultSet rs = null; 
try { 
    ps = con.prepareStatement(...); 
    rs = ps.executeQuery(); 
    if (rs.next()) ...; 
    rs.close(); 
    ps.close(); 

    ps = con.prepareStatement(...); 
    rs = ps.executeQuery(); 
    if (rs.next()) ...; 
} catch (SQLException e) { 
    System.err.println("Error: " + e); 
} finally { 
    closeAll(rs, ps, con); 
} 

considero mejor a significar tanto más seguro, más clara, más concisa, o más robusto. No estoy seguro de si este último siempre cerrará las declaraciones preparadas y los conjuntos de resultados abiertos siempre que encuentre una excepción, aunque creo que sí se ve más conciso. Pero el primero se ve mejor, ya que es más consistente, pero agrega más sobrecarga, ya que usa más bloques try finally.

Me doy cuenta de que la parte de administración de recursos automática de Java 7 de Project Coin me obligará a inclinarme por la anterior ya que los recursos utilizados en el encabezado son implícitamente finales en el cuerpo. Sin embargo, tengo bastante tiempo antes de tener que preocuparme de revisar mi código para adaptarlo a ARM y ser capaz de eliminar el código repetitivo, por lo que la pregunta sigue en pie: de los dos estilos anteriores, ¿cuál sería una mejor práctica? Si ambos hacen los comportamientos esperados, ¿estos últimos me darán un aumento notable en el rendimiento que justificaría el estilo "más feo"?

Answer 1

Me parece que este es un caso de preferencia personal. En mi tiempo he escrito un código que se parece a ambos bloques. En cuanto al rendimiento, no creo que haya una diferencia particularmente notable, solo las pruebas de rendimiento lo dirían.

Puede ser que la diferencia de un milisegundo que entrega una versión no sea ni la mitad de importante que los diez minutos que otra persona que lea el código seis meses después de haber escrito pasará a preguntar por qué.

Mi preferencia personal sería la segunda. Usted dice que tiene una conexión abierta a la base de datos. Con el primer bloque de código si se lanza una excepción, eso se manejaría, pero luego se bajaría al segundo try/catch y se volvería a intentar. Es posible que no quieras eso si el primero falló. Con el segundo, una excepción haría que salga del código y luego cierre su conexión.

He programado principalmente en C#. Fue hace unos ocho años cuando hice Java por última vez. Pero creo que hay y han habido muchos programadores de C# que han reflexionado sobre esto. Tengo de todos modos.

Answer 2

El segundo es el camino a seguir. El primero puede no cerrar la conexión cuando ocurre una excepción en el primer try-block. Cuando acaba de imprimir en stderr en el catch-block, entonces no, pero no lo hará. ¿O debería ejecutarse la segunda declaración sin respeto al éxito/fracaso de la primera?

Answer 3

Si lo miras, verás que la lógica es algo diferente: la primera versión ejecutará una segunda consulta incluso si falla el manejo de la primera consulta. La segunda versión solo procederá a ejecutar la segunda consulta, si se manejan los resultados de la primera consulta + se realizará correctamente.

Answer 4

Me doy cuenta de que esta publicación es antigua, pero si tiene la suerte de estar ejecutándose en un entorno Java7, le sugiero que utilice el try-with-resource.

Manejará el cierre de la conexión para usted, ya que las nuevas versiones de la clase implementan la interfaz Closable.

public static void viewTable(Connection con) throws SQLException { 

String query = "select COF_NAME, SUP_ID, PRICE, SALES, TOTAL from COFFEES"; 

try (Statement stmt = con.createStatement()) { 
    ResultSet rs = stmt.executeQuery(query); 

    while (rs.next()) { 
     String coffeeName = rs.getString("COF_NAME"); 
     int supplierID = rs.getInt("SUP_ID"); 
     float price = rs.getFloat("PRICE"); 
     int sales = rs.getInt("SALES"); 
     int total = rs.getInt("TOTAL"); 

     System.out.println(coffeeName + ", " + supplierID + ", " + 
          price + ", " + sales + ", " + total); 
    } 
} catch (SQLException e) { 
    JDBCTutorialUtilities.printSQLException(e); 
} 
}