[#6787] Inefficient ProxyMapper allocates a new MutablePOJOMapper del…

…egate every time
jOOQ · Nov 7, 2017 · 692d833 · 692d833
1 parent 6cf7f41
commit 692d833
Showing 1 changed file with 31 additions and 7 deletions.
diff --git a/jOOQ/src/main/java/org/jooq/impl/DefaultRecordMapper.java b/jOOQ/src/main/java/org/jooq/impl/DefaultRecordMapper.java
@@ -66,6 +66,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.concurrent.Callable;
 import java.util.stream.Stream;
 
 import javax.persistence.Column;
@@ -315,7 +316,7 @@ private final void init(E instance) {
 
         // [#1340] Allow for using non-public default constructors
         try {
-            delegate = new MutablePOJOMapper(type.getDeclaredConstructor(), instance);
+            delegate = new MutablePOJOMapper(new ConstructorCall<E>(accessible(type.getDeclaredConstructor())), instance);
             return;
         }
         catch (NoSuchMethodException ignore) {}
@@ -428,11 +429,21 @@ public final E map(R record) {
      */
     private class ProxyMapper implements RecordMapper<R, E> {
 
-        Constructor<Lookup> constructor;
+        private Constructor<Lookup>     constructor;
+        private final MutablePOJOMapper pojomapper;
+
+        ProxyMapper() {
+            this.pojomapper = new MutablePOJOMapper(new Callable<E>() {
+                @Override
+                public E call() throws Exception {
+                    return proxy();
+                }
+            }, null);
+        }
 
         @Override
         public final E map(R record) {
-            return new MutablePOJOMapper(null, proxy()).map(record);
+            return pojomapper.map(record);
         }
 
         private E proxy() {
@@ -533,6 +544,19 @@ public Object map(R record) {
         }
     }
 
+    private static final class ConstructorCall<E> implements Callable<E> {
+        private final Constructor<? extends E> constructor;
+
+        ConstructorCall(Constructor<? extends E> constructor) {
+            this.constructor = constructor;
+        }
+
+        @Override
+        public E call() throws Exception {
+            return constructor.newInstance();
+        }
+    }
+
     /**
      * Convert a record into a mutable POJO type
      * <p>
@@ -541,15 +565,15 @@ public Object map(R record) {
      */
     private class MutablePOJOMapper implements RecordMapper<R, E> {
 
-        private final Constructor<? extends E>                   constructor;
+        private final Callable<E>                                constructor;
         private final boolean                                    useAnnotations;
         private final List<java.lang.reflect.Field>[]            members;
         private final List<java.lang.reflect.Method>[]           methods;
         private final Map<String, List<RecordMapper<R, Object>>> nested;
         private final E                                          instance;
 
-        MutablePOJOMapper(Constructor<? extends E> constructor, E instance) {
-            this.constructor = accessible(constructor);
+        MutablePOJOMapper(Callable<E> constructor, E instance) {
+            this.constructor = constructor;
             this.useAnnotations = hasColumnAnnotations(configuration, type);
             this.members = new List[fields.length];
             this.methods = new List[fields.length];
@@ -629,7 +653,7 @@ private class MutablePOJOMapper implements RecordMapper<R, E> {
         @Override
         public final E map(R record) {
             try {
-                E result = instance != null ? instance : constructor.newInstance();
+                E result = instance != null ? instance : constructor.call();
 
                 for (int i = 0; i < fields.length; i++) {
                     for (java.lang.reflect.Field member : members[i]) {