Simplify a bit the pool implementation and move the actual connection pool in the PoolBase class

vietj · vietj · commit 74caf0932224 · 2020-05-13T16:15:56.000+02:00
diff --git a/vertx-db2-client/src/main/java/io/vertx/db2client/DB2Pool.java b/vertx-db2-client/src/main/java/io/vertx/db2client/DB2Pool.java
@@ -77,14 +77,14 @@ static DB2Pool pool(DB2ConnectOptions connectOptions, PoolOptions poolOptions) {
     }
     VertxOptions vertxOptions = new VertxOptions();
     Vertx vertx = Vertx.vertx(vertxOptions);
-    return new DB2PoolImpl((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);
+    return DB2PoolImpl.create((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);
   }
 
   /**
    * Like {@link #pool(DB2ConnectOptions, PoolOptions)} with a specific
    * {@link Vertx} instance.
    */
   static DB2Pool pool(Vertx vertx, DB2ConnectOptions connectOptions, PoolOptions poolOptions) {
-    return new DB2PoolImpl((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);
+    return DB2PoolImpl.create((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);
   }
 }
diff --git a/vertx-db2-client/src/main/java/io/vertx/db2client/impl/DB2ConnectionFactory.java b/vertx-db2-client/src/main/java/io/vertx/db2client/impl/DB2ConnectionFactory.java
@@ -65,7 +65,7 @@ public DB2ConnectionFactory(Vertx vertx, ContextInternal context, DB2ConnectOpti
     this.netClient = vertx.createNetClient(netClientOptions);
   }
 
-  void close() {
+  public void close() {
     netClient.close();
   }
 
diff --git a/vertx-db2-client/src/main/java/io/vertx/db2client/impl/DB2PoolImpl.java b/vertx-db2-client/src/main/java/io/vertx/db2client/impl/DB2PoolImpl.java
@@ -24,40 +24,29 @@
 import io.vertx.sqlclient.impl.Connection;
 import io.vertx.sqlclient.impl.PoolBase;
 import io.vertx.sqlclient.impl.SqlConnectionImpl;
-import io.vertx.sqlclient.impl.pool.ConnectionPool;
 
 public class DB2PoolImpl extends PoolBase<DB2PoolImpl> implements DB2Pool {
 
+  public static DB2PoolImpl create(ContextInternal context, boolean closeVertx, DB2ConnectOptions connectOptions,
+                                   PoolOptions poolOptions) {
+    return new DB2PoolImpl(context, closeVertx, poolOptions, new DB2ConnectionFactory(context.owner(), context, connectOptions));
+  }
+
   private final DB2ConnectionFactory factory;
-  private final ConnectionPool pool;
 
-  public DB2PoolImpl(ContextInternal context, boolean closeVertx, DB2ConnectOptions connectOptions,
-      PoolOptions poolOptions) {
-    super(context.owner(), closeVertx);
-    this.factory = new DB2ConnectionFactory(context.owner(), context, connectOptions);
-    this.pool = new ConnectionPool(factory, context, poolOptions.getMaxSize(), poolOptions.getMaxWaitQueueSize());
+  private DB2PoolImpl(ContextInternal context, boolean closeVertx, PoolOptions poolOptions, DB2ConnectionFactory factory) {
+    super(context, factory, poolOptions, closeVertx);
+    this.factory = factory;
   }
 
   @Override
   public void connect(Handler<AsyncResult<Connection>> completionHandler) {
     factory.connect().onComplete(completionHandler);
   }
 
-  @Override
-  public void acquire(Handler<AsyncResult<Connection>> completionHandler) {
-    pool.acquire(completionHandler);
-  }
-
   @SuppressWarnings("rawtypes")
   @Override
   protected SqlConnectionImpl wrap(ContextInternal context, Connection conn) {
     return new DB2ConnectionImpl(factory, context, conn);
   }
-
-  @Override
-  protected void doClose() {
-    pool.close();
-    factory.close();
-    super.doClose();
-  }
 }
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/MSSQLPool.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/MSSQLPool.java
@@ -36,14 +36,14 @@ static MSSQLPool pool(MSSQLConnectOptions connectOptions, PoolOptions poolOption
     }
     VertxOptions vertxOptions = new VertxOptions();
     Vertx vertx = Vertx.vertx(vertxOptions);
-    return new MSSQLPoolImpl((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);
+    return MSSQLPoolImpl.create((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);
   }
 
   /**
    * Like {@link #pool(MSSQLConnectOptions, PoolOptions)} with a specific {@link Vertx} instance.
    */
   static MSSQLPool pool(Vertx vertx, MSSQLConnectOptions connectOptions, PoolOptions poolOptions) {
-    return new MSSQLPoolImpl((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);
+    return MSSQLPoolImpl.create((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);
   }
 
 }
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/MSSQLConnectionFactory.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/MSSQLConnectionFactory.java
@@ -81,7 +81,7 @@ private void close(Handler<AsyncResult<Void>> completionHandler) {
     completionHandler.handle(Future.succeededFuture());
   }
 
-  void close() {
+  public void close() {
     netClient.close();
   }
 }
diff --git a/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/MSSQLPoolImpl.java b/vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/MSSQLPoolImpl.java
@@ -28,13 +28,16 @@
 import java.util.function.Function;
 
 public class MSSQLPoolImpl extends PoolBase<MSSQLPoolImpl> implements MSSQLPool {
+
+  public static MSSQLPoolImpl create(ContextInternal context, boolean closeVertx, MSSQLConnectOptions connectOptions, PoolOptions poolOptions) {
+    return new MSSQLPoolImpl(context, closeVertx, new MSSQLConnectionFactory(context.owner(), context, connectOptions), poolOptions);
+  }
+
   private final MSSQLConnectionFactory connectionFactory;
-  private final ConnectionPool pool;
 
-  public MSSQLPoolImpl(ContextInternal context, boolean closeVertx, MSSQLConnectOptions connectOptions, PoolOptions poolOptions) {
-    super(context.owner(), closeVertx);
-    this.connectionFactory = new MSSQLConnectionFactory(context.owner(), context, connectOptions);
-    this.pool = new ConnectionPool(connectionFactory, context, poolOptions.getMaxSize(), poolOptions.getMaxWaitQueueSize());
+  private MSSQLPoolImpl(ContextInternal context, boolean closeVertx, MSSQLConnectionFactory factory, PoolOptions poolOptions) {
+    super(context, factory, poolOptions, closeVertx);
+    this.connectionFactory = factory;
   }
 
   @Override
@@ -48,11 +51,6 @@ public void connect(Handler<AsyncResult<Connection>> completionHandler) {
     connectionFactory.connect().onComplete(completionHandler);
   }
 
-  @Override
-  public void acquire(Handler<AsyncResult<Connection>> completionHandler) {
-    pool.acquire(completionHandler);
-  }
-
   @Override
   protected SqlConnectionImpl wrap(ContextInternal context, Connection connection) {
     return new MSSQLConnectionImpl(connectionFactory, context, connection);
@@ -62,11 +60,4 @@ protected SqlConnectionImpl wrap(ContextInternal context, Connection connection)
   public <T> Future<T> withTransaction(Function<SqlClient, Future<T>> function) {
     return Future.failedFuture("Transaction is not supported for now");
   }
-
-  @Override
-  protected void doClose() {
-    pool.close();
-    connectionFactory.close();
-    super.doClose();
-  }
 }
diff --git a/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/MySQLPool.java b/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/MySQLPool.java
@@ -68,14 +68,14 @@ static MySQLPool pool(MySQLConnectOptions connectOptions, PoolOptions poolOption
     }
     VertxOptions vertxOptions = new VertxOptions();
     Vertx vertx = Vertx.vertx(vertxOptions);
-    return new MySQLPoolImpl((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);
+    return MySQLPoolImpl.create((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);
   }
 
   /**
    * Like {@link #pool(MySQLConnectOptions, PoolOptions)} with a specific {@link Vertx} instance.
    */
   static MySQLPool pool(Vertx vertx, MySQLConnectOptions connectOptions, PoolOptions poolOptions) {
-    return new MySQLPoolImpl((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);
+    return MySQLPoolImpl.create((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);
   }
 
 }
diff --git a/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/impl/MySQLConnectionFactory.java b/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/impl/MySQLConnectionFactory.java
@@ -122,7 +122,7 @@ private void close(Handler<AsyncResult<Void>> completionHandler) {
     completionHandler.handle(Future.succeededFuture());
   }
 
-  void close() {
+  public void close() {
     netClient.close();
   }
 
diff --git a/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/impl/MySQLPoolImpl.java b/vertx-mysql-client/src/main/java/io/vertx/mysqlclient/impl/MySQLPoolImpl.java
@@ -20,37 +20,27 @@
 import io.vertx.sqlclient.impl.Connection;
 import io.vertx.sqlclient.impl.PoolBase;
 import io.vertx.sqlclient.impl.SqlConnectionImpl;
-import io.vertx.sqlclient.impl.pool.ConnectionPool;
 
 public class MySQLPoolImpl extends PoolBase<MySQLPoolImpl> implements MySQLPool {
+
+  public static MySQLPoolImpl create(ContextInternal context, boolean closeVertx, MySQLConnectOptions connectOptions, PoolOptions poolOptions) {
+    return new MySQLPoolImpl(context, closeVertx, new MySQLConnectionFactory(context.owner(), context, connectOptions), poolOptions);
+  }
+
   private final MySQLConnectionFactory factory;
-  private final ConnectionPool pool;
 
-  public MySQLPoolImpl(ContextInternal context, boolean closeVertx, MySQLConnectOptions connectOptions, PoolOptions poolOptions) {
-    super(context.owner(), closeVertx);
-    this.factory = new MySQLConnectionFactory(context.owner(), context, connectOptions);
-    this.pool = new ConnectionPool(factory, context, poolOptions.getMaxSize(), poolOptions.getMaxWaitQueueSize());
+  private MySQLPoolImpl(ContextInternal context, boolean closeVertx, MySQLConnectionFactory factory, PoolOptions poolOptions) {
+    super(context, factory, poolOptions, closeVertx);
+    this.factory = factory;
   }
 
   @Override
   public void connect(Handler<AsyncResult<Connection>> completionHandler) {
     factory.connect().onComplete(completionHandler);
   }
 
-  @Override
-  public void acquire(Handler<AsyncResult<Connection>> completionHandler) {
-    pool.acquire(completionHandler);
-  }
-
   @Override
   protected SqlConnectionImpl wrap(ContextInternal context, Connection conn) {
     return new MySQLConnectionImpl(factory, context, conn);
   }
-
-  @Override
-  protected void doClose() {
-    pool.close();
-    factory.close();
-    super.doClose();
-  }
 }
diff --git a/vertx-pg-client/src/main/java/io/vertx/pgclient/PgPool.java b/vertx-pg-client/src/main/java/io/vertx/pgclient/PgPool.java
@@ -97,14 +97,14 @@ static PgPool pool(PgConnectOptions connectOptions, PoolOptions poolOptions) {
       vertxOptions.setPreferNativeTransport(true);
     }
     VertxInternal vertx = (VertxInternal) Vertx.vertx(vertxOptions);
-    return new PgPoolImpl(vertx.getOrCreateContext(), true, connectOptions, poolOptions);
+    return PgPoolImpl.create(vertx.getOrCreateContext(), true, connectOptions, poolOptions);
   }
 
   /**
    * Like {@link #pool(PgConnectOptions, PoolOptions)} with a specific {@link Vertx} instance.
    */
   static PgPool pool(Vertx vertx, PgConnectOptions connectOptions, PoolOptions poolOptions) {
-    return new PgPoolImpl(((VertxInternal)vertx).getOrCreateContext(), false, connectOptions, poolOptions);
+    return PgPoolImpl.create(((VertxInternal)vertx).getOrCreateContext(), false, connectOptions, poolOptions);
   }
 
 }
diff --git a/vertx-pg-client/src/main/java/io/vertx/pgclient/impl/PgConnectionFactory.java b/vertx-pg-client/src/main/java/io/vertx/pgclient/impl/PgConnectionFactory.java
@@ -77,7 +77,7 @@ class PgConnectionFactory implements ConnectionFactory {
     this.client = vertx.createNetClient(netClientOptions);
   }
 
-  void close() {
+  public void close() {
     client.close();
   }
 
diff --git a/vertx-pg-client/src/main/java/io/vertx/pgclient/impl/PgPoolImpl.java b/vertx-pg-client/src/main/java/io/vertx/pgclient/impl/PgPoolImpl.java
@@ -24,7 +24,6 @@
 import io.vertx.sqlclient.impl.PoolBase;
 import io.vertx.sqlclient.impl.SqlConnectionImpl;
 import io.vertx.core.*;
-import io.vertx.sqlclient.impl.pool.ConnectionPool;
 
 /**
  * Todo :
@@ -37,27 +36,15 @@
  */
 public class PgPoolImpl extends PoolBase<PgPoolImpl> implements PgPool {
 
-  private final PgConnectionFactory factory;
-  private final ConnectionPool pool;
-  private final ContextInternal contextHook;
-  private final Closeable hook;
+  public static PgPoolImpl create(ContextInternal context, boolean closeVertx, PgConnectOptions connectOptions, PoolOptions poolOptions) {
+    return new PgPoolImpl(context, closeVertx, new PgConnectionFactory(context.owner(), context, connectOptions), poolOptions);
+  }
 
-  public PgPoolImpl(ContextInternal context, boolean closeVertx, PgConnectOptions connectOptions, PoolOptions poolOptions) {
-    super(context.owner(), closeVertx);
-    this.factory = new PgConnectionFactory(context.owner(), context, connectOptions);
-    this.pool = new ConnectionPool(factory, context, poolOptions.getMaxSize(), poolOptions.getMaxWaitQueueSize());
+  private final PgConnectionFactory factory;
 
-    if (context.deploymentID() != null) {
-      contextHook = context;
-      hook = completion -> {
-        closeInternal();
-        completion.complete();
-      };
-      context.addCloseHook(hook);
-    } else {
-      contextHook = null;
-      hook = null;
-    }
+  private PgPoolImpl(ContextInternal context, boolean closeVertx, PgConnectionFactory factory, PoolOptions poolOptions) {
+    super(context, factory, poolOptions, closeVertx);
+    this.factory = factory;
   }
 
   @Override
@@ -71,27 +58,8 @@ public void connect(Handler<AsyncResult<Connection>> completionHandler) {
     factory.connect().onComplete(completionHandler);
   }
 
-  @Override
-  public void acquire(Handler<AsyncResult<Connection>> completionHandler) {
-    pool.acquire(completionHandler);
-  }
-
   @Override
   protected SqlConnectionImpl wrap(ContextInternal context, Connection conn) {
     return new PgConnectionImpl(factory, context, conn);
   }
-
-  @Override
-  protected void doClose() {
-    if (hook != null) {
-      contextHook.removeCloseHook(hook);
-    }
-    closeInternal();
-  }
-
-  private void closeInternal() {
-    pool.close();
-    factory.close();
-    super.doClose();
-  }
 }
diff --git a/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/ConnectionFactory.java b/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/ConnectionFactory.java
@@ -27,4 +27,8 @@ public interface ConnectionFactory {
    */
   Future<Connection> connect();
 
+  default void close() {
+
+  }
+
 }
diff --git a/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/PoolBase.java b/vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/PoolBase.java
diff --git a/vertx-sql-client/src/test/java/io/vertx/sqlclient/impl/pool/ConnectionQueue.java b/vertx-sql-client/src/test/java/io/vertx/sqlclient/impl/pool/ConnectionQueue.java

Original file line number	Diff line number	Diff line change
`@@ -77,14 +77,14 @@ static DB2Pool pool(DB2ConnectOptions connectOptions, PoolOptions poolOptions) {`
`77`	`77`	`}`
`78`	`78`	`VertxOptions vertxOptions = new VertxOptions();`
`79`	`79`	`Vertx vertx = Vertx.vertx(vertxOptions);`
`80`		`- return new DB2PoolImpl((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);`
	`80`	`+ return DB2PoolImpl.create((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`/**`
`84`	`84`	`* Like {@link #pool(DB2ConnectOptions, PoolOptions)} with a specific`
`85`	`85`	`* {@link Vertx} instance.`
`86`	`86`	`*/`
`87`	`87`	`static DB2Pool pool(Vertx vertx, DB2ConnectOptions connectOptions, PoolOptions poolOptions) {`
`88`		`- return new DB2PoolImpl((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);`
	`88`	`+ return DB2PoolImpl.create((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);`
`89`	`89`	`}`
`90`	`90`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public DB2ConnectionFactory(Vertx vertx, ContextInternal context, DB2ConnectOpti`
`65`	`65`	`this.netClient = vertx.createNetClient(netClientOptions);`
`66`	`66`	`}`
`67`	`67`
`68`		`- void close() {`
	`68`	`+ public void close() {`
`69`	`69`	`netClient.close();`
`70`	`70`	`}`
`71`	`71`
Original file line number	Diff line number	Diff line change
`@@ -36,14 +36,14 @@ static MSSQLPool pool(MSSQLConnectOptions connectOptions, PoolOptions poolOption`
`36`	`36`	`}`
`37`	`37`	`VertxOptions vertxOptions = new VertxOptions();`
`38`	`38`	`Vertx vertx = Vertx.vertx(vertxOptions);`
`39`		`- return new MSSQLPoolImpl((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);`
	`39`	`+ return MSSQLPoolImpl.create((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`/**`
`43`	`43`	`* Like {@link #pool(MSSQLConnectOptions, PoolOptions)} with a specific {@link Vertx} instance.`
`44`	`44`	`*/`
`45`	`45`	`static MSSQLPool pool(Vertx vertx, MSSQLConnectOptions connectOptions, PoolOptions poolOptions) {`
`46`		`- return new MSSQLPoolImpl((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);`
	`46`	`+ return MSSQLPoolImpl.create((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ private void close(Handler<AsyncResult<Void>> completionHandler) {`
`81`	`81`	`completionHandler.handle(Future.succeededFuture());`
`82`	`82`	`}`
`83`	`83`
`84`		`- void close() {`
	`84`	`+ public void close() {`
`85`	`85`	`netClient.close();`
`86`	`86`	`}`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,14 +68,14 @@ static MySQLPool pool(MySQLConnectOptions connectOptions, PoolOptions poolOption`
`68`	`68`	`}`
`69`	`69`	`VertxOptions vertxOptions = new VertxOptions();`
`70`	`70`	`Vertx vertx = Vertx.vertx(vertxOptions);`
`71`		`- return new MySQLPoolImpl((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);`
	`71`	`+ return MySQLPoolImpl.create((ContextInternal) vertx.getOrCreateContext(), true, connectOptions, poolOptions);`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`/**`
`75`	`75`	`* Like {@link #pool(MySQLConnectOptions, PoolOptions)} with a specific {@link Vertx} instance.`
`76`	`76`	`*/`
`77`	`77`	`static MySQLPool pool(Vertx vertx, MySQLConnectOptions connectOptions, PoolOptions poolOptions) {`
`78`		`- return new MySQLPoolImpl((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);`
	`78`	`+ return MySQLPoolImpl.create((ContextInternal) vertx.getOrCreateContext(), false, connectOptions, poolOptions);`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ private void close(Handler<AsyncResult<Void>> completionHandler) {`
`122`	`122`	`completionHandler.handle(Future.succeededFuture());`
`123`	`123`	`}`
`124`	`124`
`125`		`- void close() {`
	`125`	`+ public void close() {`
`126`	`126`	`netClient.close();`
`127`	`127`	`}`
`128`	`128`
Original file line number	Diff line number	Diff line change
`@@ -97,14 +97,14 @@ static PgPool pool(PgConnectOptions connectOptions, PoolOptions poolOptions) {`
`97`	`97`	`vertxOptions.setPreferNativeTransport(true);`
`98`	`98`	`}`
`99`	`99`	`VertxInternal vertx = (VertxInternal) Vertx.vertx(vertxOptions);`
`100`		`- return new PgPoolImpl(vertx.getOrCreateContext(), true, connectOptions, poolOptions);`
	`100`	`+ return PgPoolImpl.create(vertx.getOrCreateContext(), true, connectOptions, poolOptions);`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`/**`
`104`	`104`	`* Like {@link #pool(PgConnectOptions, PoolOptions)} with a specific {@link Vertx} instance.`
`105`	`105`	`*/`
`106`	`106`	`static PgPool pool(Vertx vertx, PgConnectOptions connectOptions, PoolOptions poolOptions) {`
`107`		`- return new PgPoolImpl(((VertxInternal)vertx).getOrCreateContext(), false, connectOptions, poolOptions);`
	`107`	`+ return PgPoolImpl.create(((VertxInternal)vertx).getOrCreateContext(), false, connectOptions, poolOptions);`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`}`