Tomcat连接池&空闲连接

Question

null

 <Resource
    auth="Container"
    name="jdbc/postgres"
    factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"
    type="javax.sql.DataSource"

    username="admin"
    password="..."

    driverClassName="org.postgresql.Driver"
    url="jdbc:postgresql://127.0.0.1:5432/..."
    initialSize="1"
    maxActive="50"
    minIdle="0"
    maxIdle="3"
    maxWait="-1"
    minEvictableIdleTimeMillis="1000"
    timeBetweenEvictionRunsMillis="1000"
    />

如果我理解正确的话，我们应该在启动时有1个空闲连接，根据负载从0到3，对吗？

正在发生的情况是：启动时1个连接，如果负载较低，最多3个空闲连接，高负载后超过3个空闲连接。然后这些连接不会立即关闭，我们不知道它们何时/是否会关闭（有时它们中的一些会关闭）。

所以问题是：这种行为正常吗？

public class PostgreSQLConnectionProvider {

    public static Connection getConnection() throws NamingException, SQLException {

        String dsString = "java:/comp/env/jdbc/postgres";
        Context context = new InitialContext();
        DataSource ds = (DataSource) context.lookup(dsString);
        Connection connection = ds.getConnection();

        return connection;
    }
}

public abstract class DAO implements java.lang.AutoCloseable {

    // Private attributes :
    private Connection _connection;

    // Constructors :
    public DAO() {

        try { _connection = PostgreSQLConnectionProvider.getConnection(); }
        catch (NamingException | SQLException ex) { 
            Logger.getLogger(DAO.class.getName()).log(Level.SEVERE, null, ex); 
        }
    }

    // Getters :
    public Connection getConnection() { return _connection; }

    // Closeable :
    @Override
    public void close() throws SQLException {

        if(!_connection.getAutoCommit()) {

            _connection.rollback();
            _connection.setAutoCommit(true);
        }

        _connection.close();
    }
}

public class UserDAO extends DAO {

    public User getUserWithId(int id) throws SQLException {

        PreparedStatement ps = null;
        ResultSet rs = null;

        User user = null;

        try {

            String sql = "select * from \"USER\" where id_user = ?;";

            ps = getConnection().prepareStatement(sql);
            ps.setInt(1, id);

            rs = ps.executeQuery();
            rs.next();

            String login = rs.getString("login");
            String password = rs.getString("password");
            String firstName = rs.getString("first_name");
            String lastName = rs.getString("last_name");
            String email = rs.getString("email");

            user = new User(id, login, password, firstName, lastName, email);
        }
        finally {

            if(rs != null) rs.close();
            if(ps != null) ps.close();
        }

        return user;
    }
}

DAO子类的使用示例：

try(UserDAO dao = new UserDAO()) {

    try {

        User user = dao.getUserWithId(52);
    }
    catch (SQLException ex) {

        // Handle exeption during getUserWithId
    }
}
catch (SQLException ex) {

    // Handle exeption during dao.close()
}

Answer 1

从代码中可以看出，连接似乎是在DAO的生存期内获取的，而不是在语句的生存期内，这是通常的预期。通常，您会在执行语句时从池中获取一个连接，并在完成后调用close（）将其返回到池中。

此外，在finally子句中，rs.close()和ps.close()都可能引发异常，导致错过对准备好的语句的最后一次调用。

在Java7中，还可以使用try with resources语句，它将为您关闭准备好的语句和连接。根据规范，驱动程序应该在语句关闭时为您关闭结果。