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