timeout变量似乎不对应于连接空闲的时间，而是对应于池等待返回新连接或抛出异常的时间(我看了一下这个源代码 ，不知道是不是已是最新)。 我认为跟踪“空闲”连接是相当困难的，因为在这种情况下“空闲”真正意味着什么？ 您可能希望获得连接以供以后使用。 所以我想说连接池知道你完成连接的唯一安全方法就是调用close() 。

如果你担心开发团队忘记在他们的代码中调用close() ，有一种技术我在下面描述并且我过去曾经使用过(在我的例子中我们想要跟踪未闭合的InputStream但概念是相同)。

免责声明：

我假设连接仅在单个请求期间使用，并且在连续请求期间不跨越。 在后一种情况下，您无法使用下面的解决方案。

您的连接池实现似乎已经使用了与我在下面描述的技术类似的技术(即它已经包装了连接)，所以我不可能知道这是否适用于您的情况。 我没有测试下面的代码，我只是用它来描述这个概念。

请仅在您的开发环境中使用它。 在生产中，您应该确信您的代码已经过测试并且行为正确。

如上所述，主要思想是：我们有一个中心位置(连接池)，我们从中获取资源(连接)，我们希望跟踪我们的代码是否释放了这些资源。 我们可以使用一个Web Filter ，它使用一个ThreadLocal对象来跟踪请求期间使用的连接。 我将此类命名为TrackingFilter ，跟踪资源的对象是Tracker类。

public class TrackingFilter implements Filter {

@Override

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

Tracker.start();

try {

chain.doFilter(request, response);

} finally {

Tracker.stop();

}

}

...

}

为了使Tracker能够跟踪连接，每次使用getConnection()获取连接时以及每次使用close()调用关闭连接时都需要通知它。 为了能够以对代码的其余部分透明的方式执行此操作，我们需要包装ConnectionPool和返回的Connection对象。 您的代码应该返回新的TrackingConnectionPool而不是原始池(我假设访问连接池的方式是在一个地方)。 这个新池将依次包装它提供的每个Connection ，作为TrackableConnection 。 TrackableConnection是知道如何在创建和关闭时通知我们的Tracker的对象。

当您在请求结束时调用Tracker.stop()时，它将报告尚未调用close()所有连接。 由于这是一个按请求操作，您将只识别错误操作(即在“创建新产品”功能期间)，然后希望您能够跟踪那些保留打开连接并修复它们的查询。

您可以在下面找到TrackingConnectionPool ， TrackableConnection和Tracker类的代码和注释。 为简洁起见，遗漏了代表方法。 我希望有所帮助。

注意：对于包装器使用自动IDE功能(如Eclipse的“生成委托方法”)，否则这将是一个耗时且容易出错的任务。

//------------- Pool Creation

ConnectionPool original = new ConnectionPool(String dbpoolName, ...);

TrackingConnectionPool trackingCP = new TrackingConnectionPool(original);

// ... or without creating the ConnectionPool yourself

TrackingConnectionPool trackingCP = new TrackingConnectionPool(dbpoolName, ...);

// store the reference to the trackingCP instead of the original

//------------- TrackingConnectionPool

public class TrackingConnectionPool extends ConnectionPool {

private ConnectionPool originalPool; // reference to the original pool

// Wrap all available ConnectionPool constructors like this

public TrackingConnectionPool(String dbpoolName, ...) {

originalPool = new ConnectionPool(dbpoolName, ...);

}

// ... or use this convenient constructor after you create a pool manually

public TrackingConnectionPool(ConnectionPool pool) {

this.originalPool = pool;

}

@Override

public Connection getConnection() throws SQLException {

Connection con = originalPool.getConnection();

return new TrackableConnection(con); // wrap the connections with our own wrapper

}

@Override

public Connection getConnection(long timeout) throws SQLException {

Connection con = originalPool.getConnection(timeout);

return new TrackableConnection(con); // wrap the connections with our own wrapper

}

// for all the rest public methods of ConnectionPool and its parent just delegate to the original

@Override

public void setCaching(boolean b) {

originalPool.setCaching(b);

}

...

}

//------------- TrackableConnection

public class TrackableConnection implements Connection, Tracker.Trackable {

private Connection originalConnection;

private boolean released = false;

public TrackableConnection(Connection con) {

this.originalConnection = con;

Tracker.resourceAquired(this); // notify tracker that this resource is aquired

}

// Trackable interface

@Override

public boolean isReleased() {

return this.released;

}

// Note: this method will be called by Tracker class (if needed). Do not invoke manually

@Override

public void release() {

if (!released) {

try {

// attempt to close the connection

originalConnection.close();

this.released = true;

} catch(SQLException e) {

throw new RuntimeException(e);

}

}

}

// Connection interface

@Override

public void close() throws SQLException {

originalConnection.close();

this.released = true;

Tracker.resourceReleased(this); // notify tracker that this resource is "released"

}

// rest of the methods just delegate to the original connection

@Override

public Statement createStatement() throws SQLException {

return originalConnection.createStatement();

}

....

}

//------------- Tracker

public class Tracker {

// Create a single object per thread

private static final ThreadLocal _tracker = new ThreadLocal() {

@Override

protected Tracker initialValue() {

return new Tracker();

};

};

public interface Trackable {

boolean isReleased();

void release();

}

// Stores all the resources that are used during the thread.

// When a resource is used a call should be made to resourceAquired()

// Similarly when we are done with the resource a call should be made to resourceReleased()

private Map monitoredResources = new HashMap();

// Call this at the start of each thread. It is important to clear the map

// because you can't know if the server reuses this thread

public static void start() {

Tracker monitor = _tracker.get();

monitor.monitoredResources.clear();

}

// Call this at the end of each thread. If all resources have been released

// the map should be empty. If it isn't then someone, somewhere forgot to release the resource

// A warning is issued and the resource is released.

public static void stop() {

Tracker monitor = _tracker.get();

if ( !monitor.monitoredResources.isEmpty() ) {

// there are resources that have not been released. Issue a warning and release each one of them

for (Iterator it = monitor.monitoredResources.keySet().iterator(); it.hasNext();) {

Trackable resource = it.next();

if (!resource.isReleased()) {

System.out.println("WARNING: resource " + resource + " has not been released. Releasing it now.");

resource.release();

} else {

System.out.println("Trackable " + resource

+ " is released but is still under monitoring. Perhaps you forgot to call resourceReleased()?");

}

}

monitor.monitoredResources.clear();

}

}

// Call this when a new resource is acquired i.e. you a get a connection from the pool

public static void resourceAquired(Trackable resource) {

Tracker monitor = _tracker.get();

monitor.monitoredResources.put(resource, resource);

}

// Call this when the resource is released

public static void resourceReleased(Trackable resource) {

Tracker monitor = _tracker.get();

monitor.monitoredResources.remove(resource);

}

}