Cerrar conexiones de bases de datos en Java

Me estoy confundiendo un poco, estaba leyendo lo siguiente de http://en.wikipedia.org/wiki/Java_Database_Connectivity

Connection conn = DriverManager.getConnection(
     "jdbc:somejdbcvendor:other data needed by some jdbc vendor",
     "myLogin",
     "myPassword" );

Statement stmt = conn.createStatement();
try {
    stmt.executeUpdate( "INSERT INTO MyTable( name ) VALUES ( 'my name' ) " );
} finally {
    //It's important to close the statement when you are done with it
    stmt.close();
}

¿No necesita cerrar la conexión conn? ¿Qué sucede realmente si no se produce el conn.close ()?

Tengo una aplicación web privada que mantengo que actualmente no cierra ninguno de los dos formularios, pero ¿es realmente importante el estándar, el estándar o ambos?

El sitio sigue cayendo de forma intermitente, pero el servidor sigue diciendo que es un problema de conexión de la base de datos, mi sospecha es que no se está cerrando, pero no sé cuál cerrar.

Cuando haya terminado de usar su Connection, debe cerrarlo explícitamente llamando a su close()método para liberar cualquier otro recurso de la base de datos (cursores, identificadores, etc.) a la que pueda estar reteniendo la conexión.

En realidad, el patrón seguro en Java es cerrar su ResultSet, Statementy Connection(en ese orden) en un finallybloque cuando haya terminado con ellos, algo así:

Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;

try {
    // Do stuff
    ...

} catch (SQLException ex) {
    // Exception handling stuff
    ...
} finally {
    if (rs != null) {
        try {
            rs.close();
        } catch (SQLException e) { /* ignored */}
    }
    if (ps != null) {
        try {
            ps.close();
        } catch (SQLException e) { /* ignored */}
    }
    if (conn != null) {
        try {
            conn.close();
        } catch (SQLException e) { /* ignored */}
    }
}

El finallybloque se puede mejorar ligeramente (para evitar la comprobación nula):

} finally {
    try { rs.close(); } catch (Exception e) { /* ignored */ }
    try { ps.close(); } catch (Exception e) { /* ignored */ }
    try { conn.close(); } catch (Exception e) { /* ignored */ }
}

Pero, aún así, esto es extremadamente detallado, por lo que generalmente terminas usando una clase auxiliar para cerrar los objetos en métodos auxiliares nulos y el finallybloque se convierte en algo así:

} finally {
    DbUtils.closeQuietly(rs);
    DbUtils.closeQuietly(ps);
    DbUtils.closeQuietly(conn);
}

Y, en realidad, Apache Commons DbUtils tiene una DbUtilsclase que está haciendo precisamente eso, por lo que no hay necesidad de escribir la suya.

Siempre es mejor cerrar los objetos de base de datos / recursos después de su uso. Es mejor cerrar la conexión, el conjunto de resultados y los objetos de declaración en el finallybloque.

Hasta Java7, todos estos recursos deben cerrarse utilizando un finallybloque. Si está utilizando Java 7, entonces para cerrar los recursos puede hacer lo siguiente.

try(Connection con = getConnection(url, username, password, "org.postgresql.Driver");
    Statement stmt = con.createStatement();
    ResultSet rs = stmt.executeQuery(sql);
) {

//statements
}catch(....){}

Ahora, los objetos con, stmt y rs se convierten en parte del bloque try y java cierra automáticamente estos recursos después de su uso.

Espero haber sido útil.

Es suficiente para cerrar justo Statementy Connection. No hay necesidad de cerrar explícitamente el ResultSetobjeto.

La documentación de Java dice acerca de java.sql.ResultSet:

Un objeto ResultSet se cierra automáticamente por el objeto de declaración que lo generó cuando ese objeto de declaración se cierra, se vuelve a ejecutar o se utiliza para recuperar el siguiente resultado de una secuencia de resultados múltiples.

Gracias BalusC por sus comentarios: "No confiaría en eso. Algunos controladores JDBC fallan en eso".

Si. Debe cerrar el conjunto de resultados, la declaración y la conexión. Si la conexión proviene de un grupo, cerrarla en realidad la envía de vuelta al grupo para su reutilización.

Por lo general, debe hacer esto en un finally{}bloque, de modo que si se produce una excepción, aún tiene la oportunidad de cerrar esto.

Muchos marcos se ocuparán de este problema de asignación de recursos / asignación de recursos por usted. por ejemplo Spring's JdbcTemplate . Apache DbUtils tiene métodos para buscar después de cerrar el conjunto de resultados / declaración / conexión, ya sea nulo o no (y detectar excepciones al cerrar), lo que también puede ayudar.

En realidad, es mejor si usa un bloque de prueba con recursos y Java cerrará todas las conexiones por usted cuando salga del bloque de prueba.

Debe hacer esto con cualquier objeto que implemente AutoClosable.

try (Connection connection = getDatabaseConnection(); Statement statement = connection.createStatement()) {
    String sqlToExecute = "SELECT * FROM persons";
    try (ResultSet resultSet = statement.execute(sqlToExecute)) {
        if (resultSet.next()) {
            System.out.println(resultSet.getString("name");
        }
    }
} catch (SQLException e) {
    System.out.println("Failed to select persons.");
}

La llamada a getDatabaseConnection está hecha. Reemplácelo con una llamada que le proporcione una conexión JDBC SQL o una conexión de un grupo.

Sí, necesitas cerrar la conexión. De lo contrario, el cliente de la base de datos generalmente mantendrá la conexión de socket y otros recursos abiertos.