Os conjuntos de resultados e instruções JDBC devem ser fechados separadamente, embora a conexão seja fechada posteriormente?

Diz-se ser um bom hábito fechar todos os recursos JDBC após o uso. Mas se eu tiver o código a seguir, é necessário fechar o conjunto de resultados e a instrução?

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) {};
}

A questão é se o fechamento da conexão faz o trabalho ou se deixa alguns recursos em uso.

O que você fez é uma prática perfeita e muito boa.

O motivo pelo qual digo boas práticas ... Por exemplo, se por algum motivo você estiver usando um tipo "primitivo" de pool de banco de dados e telefonar connection.close(), a conexão será retornada ao pool e o ResultSet/ Statementnunca será fechado e você vai encontrar muitos problemas diferentes!

Portanto, você nem sempre pode contar com connection.close()a limpeza.

Eu espero que isso ajude :)

O Java 1.7 facilita muito nossas vidas, graças à instrução try-with-resources .

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.
    }
}

Essa sintaxe é bastante breve e elegante. E connectionserá fechado mesmo quando o statementnão puder ser criado.

Dos javadocs :

Quando um Statementobjeto é fechado, seu ResultSetobjeto atual , se houver, também é fechado.

No entanto, os javadocs não são muito claras sobre se o Statemente ResultSetestão fechados quando você fecha o subjacente Connection. Eles simplesmente afirmam que fechar uma conexão:

Libera Connectiono banco de dados e os recursos JDBC deste objeto imediatamente, em vez de esperar que eles sejam liberados automaticamente.

Na minha opinião, sempre feche explicitamente ResultSets, Statementse Connectionsquando você terminar com eles, a implementação closepode variar entre os drivers de banco de dados.

Você pode salvar um monte de código caldeira-plate usando métodos tais como closeQuietlyem dbUtils de Apache.

Agora estou usando o Oracle com Java. Aqui está o meu ponto de vista:

Você deve fechar ResultSete Statementexplicitamente porque o Oracle tem problemas anteriormente em manter os cursores abertos, mesmo após o fechamento da conexão. Se você não fechar o ResultSet(cursor), ocorrerá um erro como o máximo de cursores abertos excedido .

Eu acho que você pode encontrar o mesmo problema com outros bancos de dados que você usa.

Aqui está o tutorial Fechar ResultSet quando terminar :

Fechar ResultSet quando terminar

Feche o ResultSetobjeto assim que terminar de trabalhar com o ResultSetobjeto, mesmo que o Statementobjeto feche o ResultSetobjeto implicitamente quando ele for fechado, o fechamento ResultSetexplicitamente dará ao coletor de lixo a chance de recuperar a memória o mais cedo possível, pois o ResultSetobjeto pode ocupar muita memória, dependendo da consulta.

ResultSet.close();

Se você quiser um código mais compacto, sugiro usar o Apache Commons DbUtils . Nesse caso:

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);
}

O método correto e seguro para fechar os recursos associados ao JDBC é este (extraído de Como Fechar Recursos JDBC Corretamente - Sempre ):

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();
}

Não importa se Connectioné poolável ou não. Até a conexão com piscina precisa ser limpa antes de retornar à piscina.

"Limpo" geralmente significa fechar conjuntos de resultados e reverter as transações pendentes, mas não fechar a conexão. Caso contrário, o pool perde o sentido.

Não, você não precisa fechar nada, exceto a conexão. Por especificações do JDBC, o fechamento de qualquer objeto superior fechará automaticamente os objetos inferiores. O fechamento Connectionfechará todos os Statements criados pela conexão. Fechar qualquer Statementfechará todos os ResultSets criados por isso Statement. Não importa se Connectioné poolável ou não. Até a conexão com piscina precisa ser limpa antes de retornar à piscina.

É claro que você pode ter longos loops aninhados na Connectioncriação de muitas instruções e, em seguida, fechá-las é apropriado. Eu quase nunca fecho ResultSet, parece excessivo ao fechar Statementou ConnectionVAI fechá-los.

Eu criei o seguinte método para criar One Liner reutilizável:

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();
        }
    }
}

Eu uso esse código em uma classe pai que é herdada de todas as minhas classes que enviam consultas de banco de dados. Eu posso usar o Oneliner em todas as consultas, mesmo se eu não tiver um resultSet. O método cuida de fechar o ResultSet, Statement, Connection na ordem correta. É assim que meu bloco finalmente se parece.

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

Tanto quanto me lembro, no JDBC atual, os conjuntos de resultados e as instruções implementam a interface AutoCloseable. Isso significa que eles são fechados automaticamente após serem destruídos ou sair do escopo.

Algumas funções de conveniência:

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);
}

Com o formato Java 6, acho melhor verificar se ele está fechado ou não antes do fechamento (por exemplo, se algum pool de conexões expulsar a conexão em outro encadeamento) - por exemplo, algum problema de rede - a instrução e o estado do conjunto de resultados podem ser fechados. (isso nem sempre acontece, mas eu tive esse problema com Oracle e DBCP). Meu padrão é esse (na sintaxe Java mais antiga) é:

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());
        }
    }
}

Em teoria, não é 100% perfeito, porque entre a verificação do estado fechado e o fechamento em si, há pouco espaço para a mudança de estado. No pior dos casos, você receberá um aviso por muito tempo. - mas é menor que a possibilidade de alteração de estado em consultas de longo prazo. Estamos usando esse padrão na produção com uma carga "média" (150 usuários simultâneos) e não tivemos nenhum problema com ele - portanto, nunca veja essa mensagem de aviso.