chiusura Connessioni di database in Java

Question

io sono sempre un po 'confuso, stavo leggendo il seguito da 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(); 
} 

Non ti necessario chiudere la connessione conn? Cosa sta succedendo veramente se conn.close() non si verifica?

Ho un'app web privata che sto mantenendo che attualmente non chiude nessuna delle due forme, ma è quella importante davvero quella stmt, quella conn o entrambe?

Il sito continua ad andare giù a intermittenza ma il server continua a dire che si tratta di un problema di connessione al database, il mio sospetto è che non sia stato chiuso, ma non so se chiuderlo.

Answer 1

Quando hai finito di usare il tuo Connection, devi chiuderlo esplicitamente chiamando il suo metodo close() per poter rilasciare qualsiasi altra risorsa del database (cursori, maniglie, ecc.) Sulla quale la connessione può essere tenuta.

In realtà, il modello di sicurezza in Java è quello di chiudere la vostra ResultSet, Statement, e Connection (in quest'ordine) in un blocco finally quando si è fatto con loro, qualcosa di simile:

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 */} 
    } 
} 

Il finally blocco può essere leggermente migliorata in (per evitare il controllo null):

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

Ma, ancora, questo è estremamente dettagliato in modo generalmente finisce per utilizzare una classe di supporto a C perdere gli oggetti in metodi di supporto nulli di sicurezza e il blocco finally diventa qualcosa di simile:

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

E, in realtà, il Apache Commons DbUtils ha una classe DbUtils che sta appunto facendo che quindi non c'è bisogno di scrivere il proprio.

Answer 2

Sì, è necessario chiudere la connessione. In caso contrario, il client del database manterrà generalmente la connessione socket e altre risorse aperte.

Answer 3

Sì. Devi chiudere il set di risultati, la dichiarazione e la connessione. Se la connessione proviene da un pool, la sua chiusura lo invia di nuovo al pool per il riutilizzo.

In genere è necessario farlo in un blocco finally{}, in modo tale che se viene generata un'eccezione, si ha comunque la possibilità di chiuderla.

Molti framework si prenderanno cura di questo problema di allocazione delle risorse/deallocazione. per esempio. Spring's JdbcTemplate. Apache DbUtils ha metodi da seguire dopo la chiusura del set di risultati/dell'istruzione/connessione sia null o meno (e cattura le eccezioni alla chiusura), il che può essere di aiuto.

Answer 4

E 'sufficiente chiudere solo Statement e Connection. Non è necessario chiudere esplicitamente l'oggetto ResultSet.

documentazione

Java dice di java.sql.ResultSet:

un oggetto ResultSet viene automaticamente chiusa dal oggetto Statement che lo ha generato quando l'oggetto Statement è chiuso, rieseguito, o viene utilizzato per recuperare il risultato successivo da un sequenza di risultati multipli.

---

Grazie BalusC per i commenti: "Non vorrei fare affidamento su che alcuni driver JDBC non su questo.".

Answer 5

È sempre preferibile chiudere gli oggetti database/risorsa dopo l'uso. È meglio chiudere gli oggetti connessione, risultati e istruzione nel blocco finally.

Fino a Java7, tutte queste risorse devono essere chiuse utilizzando un blocco finally. Se si utilizza Java 7, per chiudere le risorse è possibile procedere come segue.

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

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

Ora, con, stmt e rs oggetti diventano parte del blocco try e Java si chiude automaticamente queste risorse dopo l'uso.

Spero di essere stato utile.

Answer 6

In realtà, è meglio se si utilizza un blocco try-with-resources e Java chiuderà tutte le connessioni al momento dell'uscita dal blocco try.

È necessario eseguire questa operazione con qualsiasi oggetto che implementa 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 chiamata a getDatabaseConnection è stata appena creata. Sostituirlo con una chiamata che ti ottiene una connessione JDBC SQL o una connessione da un pool.