Cerrar las conexiones de la base de datos en Java

cerrar conexion mysql java

Question

Me estoy poniendo un poco confundido, estaba leyendo el 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 de la conexión? ¿Qué está sucediendo realmente si el conn.close () no ocurre?

Tengo una aplicación web privada que estoy manteniendo que actualmente no cierra ninguna de las dos formas, pero ¿es la más importante la primera, la que está conectada, o ambas?

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

Answer 1

Basta con cerrar Statement y Connection . No es necesario cerrar explícitamente el objeto ResultSet .

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

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

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

Answer 2

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

En realidad, el patrón seguro en Java es cerrar su ResultSet , Statement y Connection (en ese orden) en un bloque finally cuando haya terminado con ellos, algo como eso:

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 bloque finally se puede mejorar ligeramente en (para evitar la verificació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 bloque finally se convierte en algo así:

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

Y, en realidad, Apache Commons DbUtils tiene una clase DbUtils que está haciendo precisamente eso, por lo que no es necesario que escribas la tuya.

Answer 3

En realidad, es mejor si usa un bloque try-with-resources y Java cerrará todas las conexiones cuando salga del bloque try.

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.

Answer 4

Sí, debe cerrar la conexión. De lo contrario, el cliente de la base de datos mantendrá normalmente abierta la conexión de socket y otros recursos.

Answer 5

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

Normalmente tiene que hacer esto en un bloque finally{} , de modo que si se lanza una excepción, todavía tiene la oportunidad de cerrar esto.

Muchos marcos se ocuparán de este problema de asignación / desasignación de recursos. por ejemplo, Spring''s JdbcTemplate . Apache DbUtils tiene métodos para controlar el resultado / declaración / conexión, ya sea nulo o no (y detectar excepciones al cerrar), lo que también puede ser útil.

Answer 6

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

Hasta Java7, todos estos recursos deben cerrarse usando un bloque finally . 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 vuelven parte del bloque try y Java cierra automáticamente estos recursos después de su uso.

Espero que haya sido útil.