DATACMNS-1126 - Add class-generating entity instantiation support for Kotlin.

We now discover Kotlin constructors and apply parameter defaulting to allow construction of immutable value objects. Constructor discovery uses primary constructors by default and considers PersistenceConstructor annotations.

KotlinClassGeneratingEntityInstantiator can instantiate Kotlin classes with default parameters by resolving the synthetic constructor. Null values translate to parameter defaults.

class Person(val firstname: String = "Walter") {
}

class Address(val street: String, val city: String) {

	@PersistenceConstructor
	constructor(street: String = "Unknown", city: String = "Unknown", country: String) : this(street, city)
}

Original pull request: #233.

Author: mp911de

pom.xml

@@ -231,6 +231,49 @@
 			<scope>test</scope>
 		</dependency>
 
+		<!-- Kotlin extension -->
+		<dependency>
+			<groupId>org.jetbrains.kotlin</groupId>
+			<artifactId>kotlin-stdlib</artifactId>
+			<version>${kotlin}</version>
+			<optional>true</optional>
+		</dependency>
+
+		<dependency>
+			<groupId>org.jetbrains.kotlin</groupId>
+			<artifactId>kotlin-reflect</artifactId>
+			<version>${kotlin}</version>
+			<optional>true</optional>
+		</dependency>
+
+		<dependency>
+			<groupId>org.jetbrains.kotlin</groupId>
+			<artifactId>kotlin-test</artifactId>
+			<version>${kotlin}</version>
+			<scope>test</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>com.nhaarman</groupId>
+			<artifactId>mockito-kotlin</artifactId>
+			<version>1.5.0</version>
+			<scope>test</scope>
+			<exclusions>
+				<exclusion>
+					<groupId>org.jetbrains.kotlin</groupId>
+					<artifactId>kotlin-stdlib</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>org.jetbrains.kotlin</groupId>
+					<artifactId>kotlin-reflect</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>org.mockito</groupId>
+					<artifactId>mockito-core</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+
 		<!-- Scala -->
 		<dependency>
 			<groupId>org.scala-lang</groupId>

src/main/java/org/springframework/data/convert/ClassGeneratingEntityInstantiator.java

@@ -21,10 +21,8 @@
 import java.lang.reflect.Modifier;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 import org.springframework.asm.ClassWriter;
@@ -57,6 +55,19 @@
  */
 public class ClassGeneratingEntityInstantiator implements EntityInstantiator {
 
+	private static final int ARG_CACHE_SIZE = 100;
+
+	private static final ThreadLocal<Object[][]> OBJECT_POOL = ThreadLocal.withInitial(() -> {
+
+		Object[][] cached = new Object[ARG_CACHE_SIZE][];
+
+		for (int i = 0; i < ARG_CACHE_SIZE; i++) {
+			cached[i] = new Object[i];
+		}
+
+		return cached;
+	});
+
 	private final ObjectInstantiatorClassGenerator generator;
 
 	private volatile Map<TypeInformation<?>, EntityInstantiator> entityInstantiators = new HashMap<>(32);
@@ -120,12 +131,20 @@ private EntityInstantiator createEntityInstantiator(PersistentEntity<?, ?> entit
 		}
 
 		try {
-			return new EntityInstantiatorAdapter(createObjectInstantiator(entity));
+			return doCreateEntityInstantiator(entity);
 		} catch (Throwable ex) {
 			return ReflectionEntityInstantiator.INSTANCE;
 		}
 	}
 
+	/**
+	 * @param entity
+	 * @return
+	 */
+	protected EntityInstantiator doCreateEntityInstantiator(PersistentEntity<?, ?> entity) {
+		return new EntityInstantiatorAdapter(createObjectInstantiator(entity, entity.getPersistenceConstructor()));
+	}
+
 	/**
 	 * @param entity
 	 * @return
@@ -151,17 +170,46 @@ private boolean shouldUseReflectionEntityInstantiator(PersistentEntity<?, ?> ent
 	}
 
 	/**
-	 * Creates a dynamically generated {@link ObjectInstantiator} for the given {@link PersistentEntity}. There will
-	 * always be exactly one {@link ObjectInstantiator} instance per {@link PersistentEntity}.
-	 * <p>
+	 * Allocates an object array for instance creation. This method uses the argument array cache if possible.
+	 *
+	 * @param argumentCount
+	 * @return
+	 * @since 2.0
+	 * @see #ARG_CACHE_SIZE
+	 */
+	static Object[] allocateArguments(int argumentCount) {
+		return argumentCount < ARG_CACHE_SIZE ? OBJECT_POOL.get()[argumentCount] : new Object[argumentCount];
+	}
+
+	/**
+	 * Deallocates an object array used for instance creation. Parameters are cleared if the array was cached.
+	 *
+	 * @param argumentCount
+	 * @return
+	 * @since 2.0
+	 * @see #ARG_CACHE_SIZE
+	 */
+	static void deallocateArguments(Object[] params) {
+
+		if (params.length != 0 && params.length < ARG_CACHE_SIZE) {
+			Arrays.fill(params, null);
+		}
+	}
+
+	/**
+	 * Creates a dynamically generated {@link ObjectInstantiator} for the given {@link PersistentEntity} and
+	 * {@link PreferredConstructor}. There will always be exactly one {@link ObjectInstantiator} instance per
+	 * {@link PersistentEntity}.
 	 *
 	 * @param entity
+	 * @param constructor
 	 * @return
 	 */
-	private ObjectInstantiator createObjectInstantiator(PersistentEntity<?, ?> entity) {
+	ObjectInstantiator createObjectInstantiator(PersistentEntity<?, ?> entity,
+			@Nullable PreferredConstructor<?, ?> constructor) {
 
 		try {
-			return (ObjectInstantiator) this.generator.generateCustomInstantiatorClass(entity).newInstance();
+			return (ObjectInstantiator) this.generator.generateCustomInstantiatorClass(entity, constructor).newInstance();
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
@@ -172,11 +220,10 @@ private ObjectInstantiator createObjectInstantiator(PersistentEntity<?, ?> entit
 	 *
 	 * @author Thomas Darimont
 	 * @author Oliver Gierke
+	 * @author Mark Paluch
 	 */
 	private static class EntityInstantiatorAdapter implements EntityInstantiator {
 
-		private static final Object[] EMPTY_ARRAY = new Object[0];
-
 		private final ObjectInstantiator instantiator;
 
 		/**
@@ -203,6 +250,8 @@ public <T, E extends PersistentEntity<? extends T, P>, P extends PersistentPrope
 				return (T) instantiator.newInstance(params);
 			} catch (Exception e) {
 				throw new MappingInstantiationException(entity, Arrays.asList(params), e);
+			} finally {
+				deallocateArguments(params);
 			}
 		}
 
@@ -216,17 +265,18 @@ public <T, E extends PersistentEntity<? extends T, P>, P extends PersistentPrope
 		private <P extends PersistentProperty<P>, T> Object[] extractInvocationArguments(
 				@Nullable PreferredConstructor<? extends T, P> constructor, ParameterValueProvider<P> provider) {
 
-			if (provider == null || constructor == null || !constructor.hasParameters()) {
-				return EMPTY_ARRAY;
+			if (constructor == null || !constructor.hasParameters()) {
+				return allocateArguments(0);
 			}
 
-			List<Object> params = new ArrayList<>(constructor.getConstructor().getParameterCount());
+			Object[] params = allocateArguments(constructor.getConstructor().getParameterCount());
 
+			int index = 0;
 			for (Parameter<?, P> parameter : constructor.getParameters()) {
-				params.add(provider.getParameterValue(parameter));
+				params[index++] = provider.getParameterValue(parameter);
 			}
 
-			return params.toArray();
+			return params;
 		}
 	}
 
@@ -290,7 +340,7 @@ static class ObjectInstantiatorClassGenerator {
 
 		private final ByteArrayClassLoader classLoader;
 
-		private ObjectInstantiatorClassGenerator() {
+		ObjectInstantiatorClassGenerator() {
 
 			this.classLoader = AccessController.doPrivileged(
 					(PrivilegedAction<ByteArrayClassLoader>) () -> new ByteArrayClassLoader(ClassUtils.getDefaultClassLoader()));
@@ -300,12 +350,14 @@ private ObjectInstantiatorClassGenerator() {
 		 * Generate a new class for the given {@link PersistentEntity}.
 		 *
 		 * @param entity
+		 * @param constructor
 		 * @return
 		 */
-		public Class<?> generateCustomInstantiatorClass(PersistentEntity<?, ?> entity) {
+		public Class<?> generateCustomInstantiatorClass(PersistentEntity<?, ?> entity,
+				@Nullable PreferredConstructor<?, ?> constructor) {
 
 			String className = generateClassName(entity);
-			byte[] bytecode = generateBytecode(className, entity);
+			byte[] bytecode = generateBytecode(className, entity, constructor);
 
 			return classLoader.loadClass(className, bytecode);
 		}
@@ -323,9 +375,11 @@ private String generateClassName(PersistentEntity<?, ?> entity) {
 		 *
 		 * @param internalClassName
 		 * @param entity
+		 * @param constructor
 		 * @return
 		 */
-		public byte[] generateBytecode(String internalClassName, PersistentEntity<?, ?> entity) {
+		public byte[] generateBytecode(String internalClassName, PersistentEntity<?, ?> entity,
+				@Nullable PreferredConstructor<?, ?> constructor) {
 
 			ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
 
@@ -334,7 +388,7 @@ public byte[] generateBytecode(String internalClassName, PersistentEntity<?, ?>
 
 			visitDefaultConstructor(cw);
 
-			visitCreateMethod(cw, entity);
+			visitCreateMethod(cw, entity, constructor);
 
 			cw.visitEnd();
 
@@ -357,8 +411,10 @@ private void visitDefaultConstructor(ClassWriter cw) {
 		 *
 		 * @param cw
 		 * @param entity
+		 * @param constructor
 		 */
-		private void visitCreateMethod(ClassWriter cw, PersistentEntity<?, ?> entity) {
+		private void visitCreateMethod(ClassWriter cw, PersistentEntity<?, ?> entity,
+				@Nullable PreferredConstructor<?, ?> constructor) {
 
 			String entityTypeResourcePath = Type.getInternalName(entity.getType());
 
@@ -368,8 +424,6 @@ private void visitCreateMethod(ClassWriter cw, PersistentEntity<?, ?> entity) {
 			mv.visitTypeInsn(NEW, entityTypeResourcePath);
 			mv.visitInsn(DUP);
 
-			PreferredConstructor<?, ?> constructor = entity.getPersistenceConstructor();
-
 			if (constructor != null) {
 
 				Constructor<?> ctor = constructor.getConstructor();

src/main/java/org/springframework/data/convert/EntityInstantiators.java

@@ -24,10 +24,11 @@
 /**
  * Simple value object allowing access to {@link EntityInstantiator} instances for a given type falling back to a
  * default one.
- * 
+ *
  * @author Oliver Gierke
  * @author Thomas Darimont
  * @author Christoph Strobl
+ * @author Mark Paluch
  */
 public class EntityInstantiators {
 
@@ -43,7 +44,7 @@ public EntityInstantiators() {
 
 	/**
 	 * Creates a new {@link EntityInstantiators} using the given {@link EntityInstantiator} as fallback.
-	 * 
+	 *
 	 * @param fallback must not be {@literal null}.
 	 */
 	public EntityInstantiators(EntityInstantiator fallback) {
@@ -52,17 +53,17 @@ public EntityInstantiators(EntityInstantiator fallback) {
 
 	/**
 	 * Creates a new {@link EntityInstantiators} using the default fallback instantiator and the given custom ones.
-	 * 
+	 *
 	 * @param customInstantiators must not be {@literal null}.
 	 */
 	public EntityInstantiators(Map<Class<?>, EntityInstantiator> customInstantiators) {
-		this(new ClassGeneratingEntityInstantiator(), customInstantiators);
+		this(new ClassGeneratingKotlinEntityInstantiator(), customInstantiators);
 	}
 
 	/**
 	 * Creates a new {@link EntityInstantiator} using the given fallback {@link EntityInstantiator} and the given custom
 	 * ones.
-	 * 
+	 *
 	 * @param defaultInstantiator must not be {@literal null}.
 	 * @param customInstantiators must not be {@literal null}.
 	 */
@@ -78,7 +79,7 @@ public EntityInstantiators(EntityInstantiator defaultInstantiator,
 
 	/**
 	 * Returns the {@link EntityInstantiator} to be used to create the given {@link PersistentEntity}.
-	 * 
+	 *
 	 * @param entity must not be {@literal null}.
 	 * @return will never be {@literal null}.
 	 */