仅在 finally-block 中关闭 JDBC-Connections？

Question

为什么数据库连接经常在两个位置关闭，一次是在使用后直接关闭，其次是在 finally 块中使用 null 检查以防止它们被关闭两次。使用 finally 块还不够吗？ finally 块将在每种情况下执行。

这是Apache-Tomcat JNDI Datasource HOW-TO 的官方示例。他们指出，在任何情况下都必须关闭连接。我想知道为什么在主 try {} 块的末尾使用 finally 块作为关闭命令是不够的，这似乎是多余的。

    Connection conn = null;
    Statement stmt = null; // Or PreparedStatement if needed
    ResultSet rs = null;
    try
    {
        conn = ... get connection from connection pool ...
        stmt = conn.createStatement("select ...");
        rs = stmt.executeQuery();
        ... iterate through the result set ...
        rs.close ();
        rs = null;
        stmt.close ();
        stmt = null;
        conn.close (); // Return to connection pool
        conn = null; // Make sure we don't close it twice
    }
    catch (SQLException e)
    {
        ... deal with errors ...
    }
    finally
    {
        // Always make sure result sets and statements are closed,
        // and the connection is returned to the pool
        if (rs != null)
        {
            try
            {
                rs.close ();
            }
            catch (SQLException ignore)
            {
            }
            rs = null;
        }
        if (stmt != null)
        {
            try
            {
                stmt.close ();
            }
            catch (SQLException ignore)
            {
            }
            stmt = null;
        }
        if (conn != null)
        {
            try
            {
                conn.close ();
            }
            catch (SQLException ignore)
            {
            }
            conn = null;
        }
    }

我想写得更短：

    Connection conn = null;
    Statement stmt = null; // Or PreparedStatement if needed
    ResultSet rs = null;
    try
    {
        conn = ... get connection from connection pool ...
        stmt = conn.createStatement ("select ...");
        rs = stmt.executeQuery();
        ... iterate through the result set ...
    }
    catch (SQLException e)
    {
        // ... deal with errors ...
    }
    finally
    {
        // Always make sure result sets and statements are closed,
        // and the connection is returned to the pool
        try
        {
            if (rs != null)
                rs.close ();
            if (stmt != null)
                stmt.close ();
            if (conn != null)
                conn.close ();
        }
        catch (SQLException ignore)
        {
        }
    }

Answer 1

你有一个很好的问题 - 我也不懂“官方示例”。 finally 块肯定够用了。

但是，您的代码有更严重的错误，即如果 rs.close() 会抛出异常，您将有 stmt 和 conn 泄漏，您也会默默地忽略该异常。那是你不应该做的事情。从 Java 7 开始，使用 try-with-resources 构造是首选方式，但如果你不能去那里，至少要分别处理每个可能的异常（rs、stmt、conn），这样它们就不会导致彼此泄漏。

例如 Apache commons DbUtils 有 closeQuietly() 只是为了这个目的，因为它曾经是一个常见的场景。就我个人而言，我会去像 Spring JDBCTemplate 这样在幕后做这类事情的地方。

编辑：try-with-resources 由 Oracle here 解释。简而言之，你会这样做：

try (Connection conn = yourCodeToGetConnection();
    Statement stmt = con.createStatement();
    ResultSet rs = stmt.executeQuery(query)) {
    while (rs.next()) {
        String coffeeName = rs.getString("COF_NAME");
        int supplierID = rs.getInt("SUP_ID");
        float price = rs.getFloat("PRICE");
        int sales = rs.getInt("SALES");
        int total = rs.getInt("TOTAL");

        System.out.println(coffeeName + ", " + supplierID + ", " + 
                               price + ", " + sales + ", " + total);
    }
} catch (SQLException ex) {
    // log, report or raise
}

try 语句自动处理conn、stmt 和rs 在所有情况下按顺序关闭（与您声明它们的相反顺序）。可能的例外情况您仍然需要自己处理。

Answer 2

感谢许多 cmets。所以总结一下（特别是 EJP cmets 对我的问题 [关闭连接将关闭基础语句并关闭语句将自行关闭 ResultSet]）并且我认为 try-with-resource 构造有点难以阅读我建议写

Connection conn = null;
Statement stmt = null; // Or PreparedStatement if needed
ResultSet rs = null;
try
{
    conn = ... get connection from connection pool ...
    stmt = conn.createStatement ("select ...");
    rs = stmt.executeQuery();
    ... iterate through the result set ...
}
catch (SQLException e)
{
    // ... deal with errors ...
}
finally
{
    // Always make sure result sets and statements are closed,
    // and the connection is returned to the pool
    try
    {
        if (conn != null)
            conn.close ();
    }
    catch (SQLException ignore)
    {
    }
}

只关闭主连接，同时保持语句和结果集始终保持不变并由连接关闭。

对吗？

Answer 3

我更喜欢编写一个关闭连接的通用方法，可以从 finally 块中调用。

类似这样的：

Connection conn = null;        
Statement stmt = null; // Or PreparedStatement if needed        
ResultSet rs = null;

try
{
    conn = ... get connection from connection pool ...            
    stmt = conn.createStatement ("select ...");         
    rs = stmt.executeQuery();

    ... iterate through the result set ...

}
catch (SQLException e)
{
    // ... deal with errors ...
}
finally
{
    CloseTheConnection(conn);        
    CloseTheStatement(stmt);         
}

public void closeTheConnection(Connection conn){             
try{
    if(conn!=null){            
     conn.close();             
  }             
}catch(Exception ex){            
}

public void closeTheStatement(Statement stmt){             
try{            
 if( stmt != null)            
      stmt.close();            
  } catch(Exception ex){                
  }
}

通过创建不同的方法并从 finally 调用它们将确保即使您从一个方法获得任何异常，也肯定会调用另一个方法。它也可以重复使用。