Ejecución de dos declaraciones preparadas de Java con una conexión: opción de estilo

Está bien, me di cuenta de que realmente he hecho demasiadas preguntas sin contribuir a la comunidad, pero quiero sus opiniones al respecto. Di 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 quería hacer varias operaciones en mi base de datos MySQL usando 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);
}

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 que mejor significa más seguro, más claro, más conciso o más robusto. No estoy seguro de si este último siempre cerrará las declaraciones preparadas y los conjuntos de resultados que estén abiertos cada vez que encuentre una excepción, aunque creo que parece más conciso. Pero el primero se ve mejor ya que es más consistente, sin embargo, pone más sobrecarga ya que usa más bloques try finalment

Me doy cuenta de que la parte de gestión automática de recursos de Java 7 de Project Coin me obligará a inclinarme por la primera, 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 por revisar mi código para adaptarlo a ARM y poder 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, ¿me dará este último un aumento notable del rendimiento que disculpe el estilo "más feo"?