Resolve ValueTransformer's Value and Bound type parameters to determine the supported types of a ValueTransformer instead of using the methods' raw return types.

Author: twz123

src/main/java/de/zalando/sprocwrapper/globalvaluetransformer/GlobalValueTransformerLoader.java

@@ -66,18 +66,20 @@ public boolean apply(final String input) {
                 final Set<Class<?>> typesAnnotatedWith = reflections.getTypesAnnotatedWith(
                         GlobalValueTransformer.class);
                 for (final Class<?> foundGlobalValueTransformer : typesAnnotatedWith) {
-                    final Class<?> valueTransformerReturnType = ValueTransformerUtils.getUnmarshalFromDbClass(
-                            foundGlobalValueTransformer);
-                    if (valueTransformerReturnType != null) {
+                    final Class<?> valueTransformerReturnType;
+                    try {
+                        valueTransformerReturnType = ValueTransformerUtils.getUnmarshalFromDbClass(
+                                foundGlobalValueTransformer);
                         GlobalValueTransformerRegistry.register(valueTransformerReturnType,
                             (ValueTransformer<?, ?>) foundGlobalValueTransformer.newInstance());
-                        LOG.debug("Global Value Transformer [{}] for type [{}] registered. ",
-                            foundGlobalValueTransformer.getSimpleName(), valueTransformerReturnType.getSimpleName());
-                    } else {
-                        LOG.error(
-                            "Could add global transformer [{}] to global registry. Could not find method unmarshalFromDb.",
-                            foundGlobalValueTransformer);
+                    } catch (final RuntimeException e) {
+                        LOG.error("Failed to add global transformer [{}] to global registry.",
+                            foundGlobalValueTransformer, e);
+                        continue;
                     }
+
+                    LOG.debug("Global Value Transformer [{}] for type [{}] registered. ",
+                        foundGlobalValueTransformer.getSimpleName(), valueTransformerReturnType.getSimpleName());
                 }
             }
 

src/main/java/de/zalando/sprocwrapper/globalvaluetransformer/ReflectionUtils.java

@@ -1,31 +1,43 @@
 package de.zalando.sprocwrapper.globalvaluetransformer;
 
+import static com.google.common.base.Preconditions.checkArgument;
+
 import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+
+import com.google.common.reflect.TypeToken;
 
 import de.zalando.typemapper.core.ValueTransformer;
 
 public final class ValueTransformerUtils {
     private ValueTransformerUtils() { }
 
-    public static Class<?> getMarshalToDbClass(final Class<?> valueTransformer) {
-        final Method method = ReflectionUtils.findMethod(valueTransformer, "marshalToDb");
-        if (method != null) {
-            return method.getReturnType();
-        }
+    public static Class<?> getMarshalToDbClass(final ValueTransformer<?, ?> valueTransformer) {
+        return resolveReturnType(valueTransformer.getClass(), "marshalToDb", Object.class);
+    }
 
-        return null;
+    public static Class<?> getUnmarshalFromDbClass(final Class<?> clazz) {
+        return resolveReturnType(checkValueTransformerClass(clazz), "unmarshalFromDb", String.class);
     }
 
-    public static Class<?> getUnmarshalFromDbClass(final Class<?> valueTransformerClass) {
-        final Method method = ReflectionUtils.findMethod(valueTransformerClass, "unmarshalFromDb");
-        if (method != null) {
-            return method.getReturnType();
-        }
+    private static <T extends ValueTransformer<?, ?>> Class<?> resolveReturnType(final Class<T> actualClass,
+            final String methodName, final Class<?>... methodParameterTypes) {
+        final Method valueTransformerMethod = findValueTransformerMethod(methodName, methodParameterTypes);
+        final Type genericReturnType = valueTransformerMethod.getGenericReturnType();
+        return TypeToken.of(actualClass).resolveType(genericReturnType).getRawType();
+    }
 
-        return null;
+    private static Method findValueTransformerMethod(final String name, final Class<?>... parameterTypes) {
+        try {
+            return ValueTransformer.class.getMethod(name, parameterTypes);
+        } catch (final NoSuchMethodException | SecurityException e) {
+            throw new IllegalArgumentException("couldn't locate ValueTransformer method " + name, e);
+        }
     }
 
-    public static Class<?> getMarshalToDbClass(final ValueTransformer<?, ?> valueTransformerForClass) {
-        return valueTransformerForClass != null ? getMarshalToDbClass(valueTransformerForClass.getClass()) : null;
+    @SuppressWarnings("unchecked")
+    private static Class<? extends ValueTransformer<?, ?>> checkValueTransformerClass(final Class<?> clazz) {
+        checkArgument(ValueTransformer.class.isAssignableFrom(clazz), "not a ValueTransformer: %s", clazz);
+        return (Class<? extends ValueTransformer<?, ?>>) clazz;
     }
 }

src/main/java/de/zalando/sprocwrapper/globalvaluetransformer/ValueTransformerUtils.java

@@ -0,0 +1,77 @@
+package de.zalando.sprocwrapper.globalvaluetransformer;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.sameInstance;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+
+import de.zalando.typemapper.core.ValueTransformer;
+
+public class ValueTransformerUtilsTest {
+
+    /**
+     * A custom value that shall be transformed using a {@link ValueTransformer}.
+     */
+    public static class CustomValue {
+        // just a dummy type
+    }
+
+    /**
+     * A custom bound that shall be transformed using a {@link ValueTransformer}.
+     */
+    public static class CustomBound {
+        // just a dummy type
+    }
+
+    /**
+     * An example for an abstract parameterized transformer that does "something" and then delegates to a
+     * subclass's method.
+     */
+    public abstract static class AbstractParameterizedTransformer<Value, Bound> extends ValueTransformer<Value, Bound> {
+
+        @Override
+        public Bound unmarshalFromDb(final String value) {
+            return delegatedUnmarshalling(value);
+        }
+
+        @Override
+        public Value marshalToDb(final Bound bound) {
+            return delegatedMarshalling(bound);
+        }
+
+        // actual unmarshalling performed by subclasses that operate on a preprocessed value
+        protected abstract Bound delegatedUnmarshalling(String preprocessed);
+
+        // actual marshalling performed by subclasses that operate on a preprocessed value
+        protected abstract Value delegatedMarshalling(Bound preprocessed);
+    }
+
+    /**
+     * An example for a concrete transformer that uses an abstract parameterized transformer as a superclass.
+     */
+    public static class ConcreteTransformer extends AbstractParameterizedTransformer<CustomValue, CustomBound> {
+        @Override
+        protected CustomBound delegatedUnmarshalling(final String preprocessed) {
+            return null; // doesn't do anything meaningful, just an example
+        }
+
+        @Override
+        protected CustomValue delegatedMarshalling(final CustomBound preprocessed) {
+            return null; // doesn't do anything meaningful, just an example
+        }
+    }
+
+    @Test
+    public void resolvesParamterizedUnmarshalReturnType() {
+        assertThat(ValueTransformerUtils.getUnmarshalFromDbClass(ConcreteTransformer.class),
+            is(sameInstance((Object) CustomBound.class)));
+    }
+
+    @Test
+    public void resolvesParamterizedMarshalReturnType() {
+        assertThat(ValueTransformerUtils.getMarshalToDbClass(new ConcreteTransformer()),
+            is(sameInstance((Object) CustomValue.class)));
+    }
+}