MappingProvider & pooled proxies

Author: ZorTik

asql-api/src/main/java/me/zort/sqllib/api/mapping/StatementMappingFactory.java

@@ -2,6 +2,8 @@
 
 import me.zort.sqllib.api.SQLConnection;
 
+import java.util.function.Supplier;
+
 /**
  * The StatementMappingFactory is responsible for creating new {@link StatementMappingStrategy}
  * for defined interfaces.
@@ -15,11 +17,14 @@ public interface StatementMappingFactory {
    * is responsible for handling that specific interface.
    *
    * @param interfaceClass The interface class
-   * @param connection     The connection to use.
+   * @param connectionFactory     The connection factory to use.
    * @param <T>            The interface class type.
    * @return The StatementMapping.
    */
-  <T> StatementMappingStrategy<T> strategy(Class<T> interfaceClass, SQLConnection connection);
+  <T> StatementMappingStrategy<T> strategy(
+          Class<T> interfaceClass,
+          Supplier<SQLConnection> connectionFactory
+  );
 
   StatementMappingResultAdapter resultAdapter();
 

asql-core/src/main/java/me/zort/sqllib/SQLDatabaseConnection.java

@@ -10,7 +10,6 @@
 import me.zort.sqllib.api.data.Row;
 import me.zort.sqllib.api.mapping.StatementMappingFactory;
 import me.zort.sqllib.api.mapping.StatementMappingOptions;
-import me.zort.sqllib.api.mapping.StatementMappingRegistry;
 import me.zort.sqllib.api.model.SchemaSynchronizer;
 import me.zort.sqllib.api.model.TableSchema;
 import me.zort.sqllib.api.model.TableSchemaBuilder;
@@ -19,6 +18,7 @@
 import me.zort.sqllib.internal.impl.QueryResultImpl;
 import me.zort.sqllib.internal.query.*;
 import me.zort.sqllib.internal.query.part.SetStatement;
+import me.zort.sqllib.mapping.MappingProvider;
 import me.zort.sqllib.transaction.Transaction;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
@@ -42,7 +42,8 @@
  * @author ZorTik
  */
 @SuppressWarnings("unused")
-public abstract class SQLDatabaseConnection implements SQLConnection, Closeable {
+public abstract class SQLDatabaseConnection
+        extends MappingProvider implements SQLConnection, Closeable {
 
   private final SQLConnectionFactory connectionFactory;
   private final transient List<SQLDatabaseConnectionImpl.CodeObserver> codeHandlers;
@@ -54,20 +55,15 @@ public abstract class SQLDatabaseConnection implements SQLConnection, Closeable
   private int errorCount = 0;
 
   public SQLDatabaseConnection(final @NotNull SQLConnectionFactory connectionFactory) {
+    super();
     this.connectionFactory = connectionFactory;
     this.connection = null;
     this.codeHandlers = new CopyOnWriteArrayList<>();
 
+    setMConnectionFactory(() -> this);
     registerConnection(this);
   }
 
-  /**
-   * Sets a mapping to use when using {@link SQLDatabaseConnection#createProxy(Class, StatementMappingOptions)}.
-   *
-   * @param mappingFactory Mapping factory to use.
-   */
-  public abstract void setProxyMapping(final @NotNull StatementMappingFactory mappingFactory);
-
   /**
    * Sets the schema synchronizer to use with synchronizeModel methods.
    *
@@ -76,50 +72,6 @@ public SQLDatabaseConnection(final @NotNull SQLConnectionFactory connectionFacto
   @ApiStatus.Experimental
   public abstract void setSchemaSynchronizer(SchemaSynchronizer<SQLDatabaseConnection> synchronizer);
 
-  @ApiStatus.Experimental
-  public abstract StatementMappingRegistry getMappingRegistry();
-
-  /**
-   * @deprecated Use {@link SQLDatabaseConnection#createProxy(Class)} instead.
-   */
-  @Deprecated
-  public abstract <T> T createGate(Class<T> mappingInterface);
-
-  /**
-   * Constructs a mapping repository based on provided interface.
-   * The interface should follow rules for creating mapping repositories
-   * in this library.
-   * <p>
-   * Example:
-   * <pre>
-   *     &#64;Table("users")
-   *     public interface MyRepository {
-   *          &#64;Select("*")
-   *          &#64;Where(&#64;Where.Condition(column = "firstname", value = "{First Name}"))
-   *          &#64;Limit(1)
-   *          Optional&lt;User&gt; getUser(&#64;Placeholder("First Name") String firstName);
-   *
-   *          &#64;Select
-   *          List&lt;User&gt; getUsers();
-   *
-   *          &#64;Delete
-   *          QueryResult deleteUsers();
-   *     }
-   *
-   *     SQLDatabaseConnection connection = ...;
-   *     MyRepository repository = connection.createGate(MyRepository.class);
-   *
-   *     Optional&lt;User&gt; user = repository.getUser("John");
-   * </pre>
-   *
-   * @param mappingInterface Interface to create mapping repository for.
-   * @param <T>              Type of mapping repository.
-   * @return Mapping repository.
-   */
-  public abstract <T> T createProxy(Class<T> mappingInterface);
-
-  public abstract <T> T createProxy(Class<T> mappingInterface, @NotNull StatementMappingOptions options);
-
   public abstract boolean buildEntitySchema(String tableName, Class<?> entityClass);
 
   /**

asql-core/src/main/java/me/zort/sqllib/SQLDatabaseConnectionImpl.java

@@ -13,10 +13,6 @@
 import me.zort.sqllib.api.data.QueryResult;
 import me.zort.sqllib.api.data.QueryRowsResult;
 import me.zort.sqllib.api.data.Row;
-import me.zort.sqllib.api.mapping.MappingProxyInstance;
-import me.zort.sqllib.api.mapping.StatementMappingFactory;
-import me.zort.sqllib.api.mapping.StatementMappingOptions;
-import me.zort.sqllib.api.mapping.StatementMappingRegistry;
 import me.zort.sqllib.api.model.SchemaSynchronizer;
 import me.zort.sqllib.api.model.TableSchema;
 import me.zort.sqllib.api.model.TableSchemaBuilder;
@@ -28,12 +24,9 @@
 import me.zort.sqllib.internal.fieldResolver.LinkedOneFieldResolver;
 import me.zort.sqllib.internal.impl.DefaultObjectMapper;
 import me.zort.sqllib.internal.impl.QueryResultImpl;
-import me.zort.sqllib.mapping.DefaultStatementMappingFactory;
-import me.zort.sqllib.mapping.MappingRegistryImpl;
-import me.zort.sqllib.mapping.ProxyInstanceImpl;
+import me.zort.sqllib.model.SQLSchemaSynchronizer;
 import me.zort.sqllib.model.builder.DatabaseSchemaBuilder;
 import me.zort.sqllib.model.builder.EntitySchemaBuilder;
-import me.zort.sqllib.model.SQLSchemaSynchronizer;
 import me.zort.sqllib.pool.PooledSQLDatabaseConnection;
 import me.zort.sqllib.transaction.Transaction;
 import me.zort.sqllib.util.Validator;
@@ -43,7 +36,6 @@
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
-import java.lang.reflect.Proxy;
 import java.sql.*;
 import java.util.HashMap;
 import java.util.Map;
@@ -80,8 +72,6 @@ static SQLDatabaseOptions defaultOptions() {
 
   @Getter
   private final ISQLDatabaseOptions options;
-  private final transient StatementMappingRegistry mappingRegistry;
-  private transient StatementMappingFactory mappingFactory;
   private transient ObjectMapper objectMapper;
   private transient CacheManager cacheManager;
   @Setter
@@ -110,10 +100,8 @@ public SQLDatabaseConnectionImpl(final @NotNull SQLConnectionFactory connectionF
     super(connectionFactory);
     this.options = options == null ? defaultOptions() : options;
     this.objectMapper = new DefaultObjectMapper(this);
-    this.mappingFactory = new DefaultStatementMappingFactory();
     this.transaction = null;
     this.logger = Logger.getGlobal();
-    this.mappingRegistry = new MappingRegistryImpl(this);
 
     setSchemaSynchronizer(new SQLSchemaSynchronizer());
     enableCaching(CacheManager.noCache());
@@ -146,15 +134,6 @@ public void setObjectMapper(final @NotNull ObjectMapper objectMapper) {
     this.objectMapper = Objects.requireNonNull(objectMapper, "Object mapper cannot be null!");
   }
 
-  /**
-   * Sets a mapping to use when using {@link SQLDatabaseConnection#createProxy(Class, StatementMappingOptions)}.
-   *
-   * @param mappingFactory Mapping factory to use.
-   */
-  public void setProxyMapping(final @NotNull StatementMappingFactory mappingFactory) {
-    this.mappingFactory = Objects.requireNonNull(mappingFactory, "Mapping factory cannot be null!");
-  }
-
   /**
    * Enabled caching for this connection.
    *
@@ -176,7 +155,7 @@ public void enableCaching(CacheManager cacheManager) {
   @ApiStatus.Experimental
   @Override
   public boolean synchronizeModel() {
-    return mappingRegistry.getProxyInstances()
+    return getMappingRegistry().getProxyInstances()
             .stream().flatMap(i -> i.getTableSchemas(
                     getOptions().getNamingStrategy(),
                     this instanceof SQLiteDatabaseConnection).stream())
@@ -235,86 +214,6 @@ public SchemaSynchronizer<SQLDatabaseConnection> getSchemaSynchronizer() {
     return schemaSynchronizer;
   }
 
-  @ApiStatus.Experimental
-  @Override
-  public StatementMappingRegistry getMappingRegistry() {
-    return mappingRegistry;
-  }
-
-  /**
-   * Constructs a mapping proxy based on provided interface.
-   * The interface should follow rules for creating mapping repositories
-   * in this library.
-   *
-   * @param mappingInterface Interface to create mapping repository for.
-   * @param <T>              Type of mapping repository.
-   * @return Mapping repository.
-   * @see SQLDatabaseConnection#createProxy(Class, StatementMappingOptions)
-   */
-  public <T> T createProxy(Class<T> mappingInterface) {
-    return createProxy(mappingInterface, new StatementMappingOptions.Builder().build());
-  }
-
-  /**
-   * Replaced with {@link SQLDatabaseConnection#createProxy(Class)}.
-   *
-   * @deprecated Will be removed in future releases.
-   */
-  @Deprecated
-  @Override
-  public <T> T createGate(Class<T> mappingInterface) {
-    return createProxy(mappingInterface);
-  }
-
-  /**
-   * Constructs a mapping repository based on provided interface.
-   * The interface should follow rules for creating mapping repositories
-   * in this library.
-   * <p>
-   * Example:
-   * <pre>
-   *     &#64;Table("users")
-   *     public interface MyRepository {
-   *          &#64;Select("*")
-   *          &#64;Where(&#64;Where.Condition(column = "firstname", value = "{First Name}"))
-   *          &#64;Limit(1)
-   *          Optional&lt;User&gt; getUser(&#64;Placeholder("First Name") String firstName);
-   *
-   *          &#64;Select
-   *          List&lt;User&gt; getUsers();
-   *
-   *          &#64;Delete
-   *          QueryResult deleteUsers();
-   *     }
-   *
-   *     SQLDatabaseConnection connection = ...;
-   *     MyRepository repository = connection.createGate(MyRepository.class);
-   *
-   *     Optional&lt;User&gt; user = repository.getUser("John");
-   * </pre>
-   *
-   * @param mappingInterface Interface to create mapping repository for.
-   * @param <T>              Type of mapping repository.
-   * @return Mapping repository.
-   */
-  @SuppressWarnings("unchecked")
-  public final <T> T createProxy(final @NotNull Class<T> mappingInterface, final @NotNull StatementMappingOptions options) {
-    Objects.requireNonNull(mappingInterface, "Mapping interface cannot be null!");
-    Objects.requireNonNull(options, "Options cannot be null!");
-
-    AtomicReference<MappingProxyInstance<T>> instanceReference = new AtomicReference<>();
-    T rawInstance = (T) Proxy.newProxyInstance(mappingInterface.getClassLoader(),
-            new Class[]{mappingInterface}, (proxy, method, args) -> instanceReference.get().invoke(proxy, method, args));
-    instanceReference.set(new ProxyInstanceImpl<>(mappingInterface,
-            options,
-            mappingFactory.strategy(mappingInterface, this),
-            mappingFactory.resultAdapter()));
-
-    MappingProxyInstance<T> proxyInstanceWrapper = instanceReference.get();
-    mappingRegistry.registerProxy(proxyInstanceWrapper);
-    return rawInstance;
-  }
-
   @ApiStatus.Experimental
   public final boolean buildEntitySchema(final @NotNull String tableName, final @NotNull Class<?> entityClass) {
     Objects.requireNonNull(entityClass, "Entity class cannot be null!");

asql-core/src/main/java/me/zort/sqllib/mapping/DefaultStatementMapping.java

@@ -6,6 +6,7 @@
 import me.zort.sqllib.api.data.QueryRowsResult;
 import me.zort.sqllib.api.mapping.StatementMappingOptions;
 import me.zort.sqllib.api.mapping.StatementMappingStrategy;
+import me.zort.sqllib.internal.factory.SQLConnectionFactory;
 import me.zort.sqllib.internal.query.QueryNode;
 import me.zort.sqllib.internal.query.ResultSetAware;
 import me.zort.sqllib.mapping.annotation.Append;
@@ -16,6 +17,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.lang.reflect.Parameter;
+import java.util.function.Supplier;
 
 /**
  * This mapping strategy uses annotations from me.zort.sqllib.mapping.annotation
@@ -26,10 +28,10 @@
  */
 public class DefaultStatementMapping<T> implements StatementMappingStrategy<T> {
 
-  private final SQLConnection connection;
+  private final Supplier<SQLConnection> connectionFactory;
 
-  public DefaultStatementMapping(SQLConnection connection) {
-    this.connection = connection;
+  public DefaultStatementMapping(Supplier<SQLConnection> connectionFactory) {
+    this.connectionFactory = connectionFactory;
   }
 
   @SuppressWarnings("unchecked")
@@ -42,33 +44,43 @@ public QueryResult executeQuery(StatementMappingOptions options, Method method,
       i++;
     }
 
-    Annotation queryAnnotation = filterQueryAnnotation(method, args);
-    QueryAnnotation wrappedAnnotation = QueryAnnotation.wrap(queryAnnotation);
+    SQLConnection connection = connectionFactory.get();
 
-    if (wrappedAnnotation == null) {
-      throw new SQLMappingException("No query builder found for method " + method.getName() + "! Is query annotation present?", method, args);
-    } else if (!(connection instanceof SQLDatabaseConnection)) {
-      throw new SQLMappingException("Connection is not a SQLDatabaseConnection!", method, args);
-    }
+    try {
+      Annotation queryAnnotation = filterQueryAnnotation(method, args);
+      QueryAnnotation wrappedAnnotation = QueryAnnotation.wrap(queryAnnotation);
 
-    QueryNode<?> node = wrappedAnnotation.getQueryBuilder().build(
-            new QueryAnnotation.DefaultMappingDetails(connection, options), queryAnnotation,
-            method, parameters);
-    if (method.isAnnotationPresent(Append.class)) {
-      Append append = method.getAnnotation(Append.class);
-      node.then(new PlaceholderMapper(parameters).assignValues(append.value()));
-    }
+      if (wrappedAnnotation == null) {
+        throw new SQLMappingException("No query builder found for method " + method.getName() + "! Is query annotation present?", method, args);
+      } else if (!(connection instanceof SQLDatabaseConnection)) {
+        throw new SQLMappingException("Connection is not a SQLDatabaseConnection!", method, args);
+      }
 
-    if (mapTo != null && wrappedAnnotation.isProducesResult() && QueryRowsResult.class.isAssignableFrom(mapTo)) {
-      return ((SQLDatabaseConnection) connection).query(node);
-    }
+      QueryNode<?> node = wrappedAnnotation.getQueryBuilder().build(
+              new QueryAnnotation.DefaultMappingDetails(connection, options), queryAnnotation,
+              method, parameters);
+      if (method.isAnnotationPresent(Append.class)) {
+        Append append = method.getAnnotation(Append.class);
+        node.then(new PlaceholderMapper(parameters).assignValues(append.value()));
+      }
 
-    if (wrappedAnnotation.isProducesResult() && node instanceof ResultSetAware) {
-      return mapTo != null
-              ? ((SQLDatabaseConnection) connection).query(node, mapTo)
-              : ((SQLDatabaseConnection) connection).query(node);
-    } else {
-      return ((SQLDatabaseConnection) connection).exec(node);
+      if (mapTo != null && wrappedAnnotation.isProducesResult() && QueryRowsResult.class.isAssignableFrom(mapTo)) {
+        return ((SQLDatabaseConnection) connection).query(node);
+      }
+
+      if (wrappedAnnotation.isProducesResult() && node instanceof ResultSetAware) {
+        return mapTo != null
+                ? ((SQLDatabaseConnection) connection).query(node, mapTo)
+                : ((SQLDatabaseConnection) connection).query(node);
+      } else {
+        return ((SQLDatabaseConnection) connection).exec(node);
+      }
+    } finally {
+      if (connection instanceof SQLDatabaseConnection) {
+        ((SQLDatabaseConnection) connection).close();
+      } else {
+        connection.disconnect();
+      }
     }
   }