Müssen JDBC-Ergebnismengen und -Anweisungen separat geschlossen werden, obwohl die Verbindung danach geschlossen wird?

Es wird als gute Angewohnheit bezeichnet, alle JDBC-Ressourcen nach der Verwendung zu schließen. Aber wenn ich den folgenden Code habe, ist es notwendig, die Ergebnismenge und die Anweisung zu schließen?

Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try {
    conn = // Retrieve connection
    stmt = conn.prepareStatement(// Some SQL);
    rs = stmt.executeQuery();
} catch(Exception e) {
    // Error Handling
} finally {
    try { if (rs != null) rs.close(); } catch (Exception e) {};
    try { if (stmt != null) stmt.close(); } catch (Exception e) {};
    try { if (conn != null) conn.close(); } catch (Exception e) {};
}

Die Frage ist, ob das Schließen der Verbindung den Job erledigt oder ob einige Ressourcen verwendet werden.

Was Sie getan haben, ist perfekt und sehr gute Praxis.

Der Grund, warum ich es als gute Praxis bezeichne ... Wenn Sie beispielsweise aus irgendeinem Grund einen "primitiven" Datenbankpooling-Typ verwenden und aufrufen connection.close(), wird die Verbindung zum Pool zurückgegeben und das ResultSet/ Statementwird niemals geschlossen und dann Sie wird auf viele verschiedene neue Probleme stoßen!

Sie können sich also nicht immer darauf verlassen connection.close(), aufzuräumen.

Ich hoffe das hilft :)

Java 1.7 erleichtert unser Leben dank der Anweisung "Try-with-Resources" erheblich .

try (Connection connection = dataSource.getConnection();
    Statement statement = connection.createStatement()) {
    try (ResultSet resultSet = statement.executeQuery("some query")) {
        // Do stuff with the result set.
    }
    try (ResultSet resultSet = statement.executeQuery("some query")) {
        // Do more stuff with the second result set.
    }
}

Diese Syntax ist sehr kurz und elegant. Und connectionwird in der Tat geschlossen, auch wenn das statementnicht erstellt werden konnte.

Aus den Javadocs :

Wenn ein StatementObjekt geschlossen wird, wird auch sein aktuelles ResultSetObjekt, falls vorhanden, geschlossen.

Die Javadocs sind sich jedoch nicht ganz sicher, ob die Statementund ResultSetgeschlossen sind, wenn Sie den Basiswert schließen Connection. Sie geben einfach an, dass das Schließen einer Verbindung:

Gibt Connectiondie Datenbank und die JDBC-Ressourcen dieses Objekts sofort frei, anstatt darauf zu warten, dass sie automatisch freigegeben werden.

Meiner Meinung nach immer explizit schließen ResultSets, Statementsund Connectionswenn Sie damit fertig sind, kann die Implementierung von closezwischen Datenbanktreibern variieren.

Mit Methoden wie closeQuietlyin DBUtils von Apache können Sie sich viel Kesselplattencode sparen .

Ich benutze jetzt Oracle mit Java. Hier mein Standpunkt:

Sie sollten schließen ResultSetund Statementexplizit, da Oracle zuvor Probleme hat, die Cursor auch nach dem Schließen der Verbindung offen zu halten. Wenn Sie den ResultSet(Cursor) nicht schließen , wird ein Fehler wie " Maximale Anzahl offener Cursor überschritten" ausgegeben .

Ich denke, dass Sie bei anderen von Ihnen verwendeten Datenbanken möglicherweise auf dasselbe Problem stoßen.

Hier ist das Tutorial Schließen Sie ResultSet, wenn Sie fertig sind :

Schließen Sie ResultSet, wenn Sie fertig sind

Schließen Sie das ResultSetObjekt, sobald Sie mit der Arbeit mit dem ResultSetObjekt fertig sind, obwohl das StatementObjekt das ResultSetObjekt beim Schließen implizit schließt. Durch das ResultSetexplizite Schließen kann der Garbage Collector den Speicher so früh wie möglich wiederherstellen, da das ResultSetObjekt je nach Abfrage möglicherweise viel Speicher belegt.

ResultSet.close();

Wenn Sie kompakteren Code wünschen, empfehle ich die Verwendung von Apache Commons DbUtils . In diesem Fall:

Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try {
    conn = // Retrieve connection
    stmt = conn.prepareStatement(// Some SQL);
    rs = stmt.executeQuery();
} catch(Exception e) {
    // Error Handling
} finally {
    DbUtils.closeQuietly(rs);
    DbUtils.closeQuietly(stmt);
    DbUtils.closeQuietly(conn);
}

Die richtige und sichere Methode zum Schließen der mit JDBC verknüpften Ressourcen (siehe So schließen Sie JDBC-Ressourcen jedes Mal richtig ):

Connection connection = dataSource.getConnection();
try {
    Statement statement = connection.createStatement();

    try {
        ResultSet resultSet = statement.executeQuery("some query");

        try {
            // Do stuff with the result set.
        } finally {
            resultSet.close();
        }
    } finally {
        statement.close();
    }
} finally {
    connection.close();
}

Es spielt keine Rolle, ob ConnectionPooling möglich ist oder nicht. Sogar die Pool-Verbindung muss gereinigt werden, bevor Sie zum Pool zurückkehren.

"Bereinigen" bedeutet normalerweise, Ergebnismengen zu schließen und ausstehende Transaktionen zurückzusetzen, aber die Verbindung nicht zu schließen. Andernfalls verliert das Pooling seinen Sinn.

Nein, Sie müssen nichts schließen, ABER die Verbindung. Gemäß den JDBC-Spezifikationen werden beim Schließen eines höheren Objekts automatisch niedrigere Objekte geschlossen. Durch das Schließen Connectionwerden alle von Statementder Verbindung erstellten s geschlossen. Wenn Sie eine Statementschließen, werden alle ResultSets geschlossen, die dadurch erstellt wurden Statement. Es spielt keine Rolle, ob ConnectionPooling möglich ist oder nicht. Sogar die Pool-Verbindung muss gereinigt werden, bevor Sie zum Pool zurückkehren.

Natürlich haben Sie möglicherweise lange verschachtelte Schleifen Connection, um viele Anweisungen zu erstellen. Dann ist es angebracht, diese zu schließen. Ich schließe fast nie ResultSet, scheine beim Schließen übertrieben Statementoder Connectionwerde sie schließen.

Ich habe die folgende Methode erstellt, um wiederverwendbaren One Liner zu erstellen:

public void oneMethodToCloseThemAll(ResultSet resultSet, Statement statement, Connection connection) {
    if (resultSet != null) {
        try {
            if (!resultSet.isClosed()) {
                resultSet.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (statement != null) {
        try {
            if (!statement.isClosed()) {
                statement.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    if (connection != null) {
        try {
            if (!connection.isClosed()) {
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Ich verwende diesen Code in einer übergeordneten Klasse, die an alle meine Klassen geerbt wurde, die DB-Abfragen senden. Ich kann den Oneliner für alle Abfragen verwenden, auch wenn ich kein resultSet habe. Die Methode sorgt dafür, dass ResultSet, Statement, Connection in der richtigen Reihenfolge geschlossen werden. So sieht mein Endblock aus.

finally {
    oneMethodToCloseThemAll(resultSet, preStatement, sqlConnection);
}

Soweit ich mich erinnere, implementieren Resultsets und Anweisungen im aktuellen JDBC die AutoCloseable-Schnittstelle. Das heißt, sie werden automatisch geschlossen, wenn sie zerstört werden oder den Geltungsbereich verlassen.

Einige Komfortfunktionen:

public static void silentCloseResultSets(Statement st) {
    try {
        while (!(!st.getMoreResults() && (st.getUpdateCount() == -1))) {}
    } catch (SQLException ignore) {}
}
public static void silentCloseResultSets(Statement ...statements) {
    for (Statement st: statements) silentCloseResultSets(st);
}

Mit Java 6 Form ist es meiner Meinung nach besser zu überprüfen, ob es geschlossen ist oder nicht, bevor es geschlossen wird (zum Beispiel, wenn ein Verbindungspooler die Verbindung in einem anderen Thread entfernt) - zum Beispiel ein Netzwerkproblem -, dass die Anweisung und der Ergebnismengenstatus geschlossen werden können. (Es kommt nicht oft vor, aber ich hatte dieses Problem mit Oracle und DBCP). Mein Muster dafür ist (in älterer Java-Syntax):

try {
    //...   
    return resp;
} finally {
    if (rs != null && !rs.isClosed()) {
        try {
            rs.close();
        } catch (Exception e2) { 
            log.warn("Cannot close resultset: " + e2.getMessage());
        }
    }
    if (stmt != null && !stmt.isClosed()) {
        try {
            stmt.close();
        } catch (Exception e2) {
            log.warn("Cannot close statement " + e2.getMessage()); 
        }
    }
    if (con != null && !conn.isClosed()) {
        try {
            con.close();
        } catch (Exception e2) {
            log.warn("Cannot close connection: " + e2.getMessage());
        }
    }
}

Theoretisch ist es nicht 100% perfekt, da zwischen der Überprüfung des Schließzustands und dem Schließen selbst ein kleiner Raum für die Zustandsänderung besteht. Im schlimmsten Fall erhalten Sie lange eine Warnung. - aber es ist weniger als die Möglichkeit einer Statusänderung bei langfristigen Abfragen. Wir verwenden dieses Muster in der Produktion mit einer "durchschnittlichen" Last (150 gleichzeitige Benutzer) und hatten kein Problem damit - sehen Sie diese Warnmeldung also nie.