Merge pull request #25 from twz123/consider-abstract-valuetransformers

Improve ValueTransformer type detection

Author: vadeg

pom.xml

@@ -180,7 +180,7 @@
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
-            <version>14.0.1</version>
+            <version>22.0</version>
         </dependency>
         <dependency>
             <groupId>javax.persistence</groupId>
@@ -195,7 +195,7 @@
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>2.0.31-beta</version>
+            <version>2.8.47</version>
             <scope>test</scope>
         </dependency>
     </dependencies>

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

@@ -1,7 +1,6 @@
 package de.zalando.sprocwrapper.proxy;
 
 import java.lang.reflect.Method;
-import java.lang.reflect.Type;
 
 import java.sql.Connection;
 
@@ -18,17 +17,15 @@
 
 public class GlobalValueTransformedParameter extends StoredProcedureParameter {
 
-    private StoredProcedureParameter forwardingStoredProcedureParameter;
-    @SuppressWarnings("rawtypes")
-    private ValueTransformer valueTransformerForClass;
+    private final StoredProcedureParameter forwardingStoredProcedureParameter;
 
-    @SuppressWarnings("rawtypes")
-    private ObjectMapper globalObjectMapper;
+    private final ValueTransformer<?, ?> valueTransformerForClass;
+
+    private final ObjectMapper<?> globalObjectMapper;
 
     public GlobalValueTransformedParameter(final ValueTransformer<?, ?> valueTransformerForClass, final Class<?> clazz,
-            final Type genericType, final Method m, final String typeName, final int sqlType, final int javaPosition,
-            final boolean sensitive, final ObjectMapper<?> globalObjectMapper) throws InstantiationException,
-        IllegalAccessException {
+            final Method m, final String typeName, final int javaPosition, final boolean sensitive,
+            final ObjectMapper<?> globalObjectMapper) throws InstantiationException, IllegalAccessException {
         super(getValueTransformedClazz(clazz, valueTransformerForClass), m, typeName, getValueTransformedTypeId(clazz),
             javaPosition, sensitive);
 
@@ -64,11 +61,12 @@ public Object mapParam(final Object value, final Connection connection) {
         }
     }
 
+    @SuppressWarnings("unchecked")
     private Object getMarshaledObject(final Object o) {
         if (globalObjectMapper != null) {
-            return globalObjectMapper.marshalToDb(o);
+            return ((ObjectMapper<Object>) globalObjectMapper).marshalToDb(o);
         } else {
-            return valueTransformerForClass.marshalToDb(o);
+            return ((ValueTransformer<?, Object>) valueTransformerForClass).marshalToDb(o);
         }
     }
 

src/main/java/de/zalando/sprocwrapper/proxy/GlobalValueTransformedParameter.java

@@ -7,7 +7,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.google.common.base.Objects;
+import com.google.common.base.MoreObjects;
 import com.google.common.reflect.AbstractInvocationHandler;
 
 import de.zalando.sprocwrapper.dsprovider.DataSourceProvider;
@@ -56,9 +56,9 @@ protected Object handleInvocation(final Object proxy, final Method method, final
     @Override
     public String toString() {
         return
-            Objects.toStringHelper(this)                          //
-                   .addValue(description)                         //
-                   .add("dataSourceProvider", dataSourceProvider) //
-                   .toString();
+            MoreObjects.toStringHelper(this)                          //
+                       .addValue(description)                         //
+                       .add("dataSourceProvider", dataSourceProvider) //
+                       .toString();
     }
 }

src/main/java/de/zalando/sprocwrapper/proxy/SProcProxy.java

@@ -67,8 +67,8 @@ public static StoredProcedureParameter createParameter(final Class<?> clazz, fin
         if (valueTransformerForClass != null) {
 
             // inject the additional logic to transform types and values
-            return new GlobalValueTransformedParameter(valueTransformerForClass, clazz, genericType, m, typeName,
-                    sqlType, javaPosition, sensitive, globalObjectMapper);
+            return new GlobalValueTransformedParameter(valueTransformerForClass, clazz, m, typeName, javaPosition,
+                    sensitive, globalObjectMapper);
         } else {
             Integer typeId = sqlType;
             if (typeId == null || typeId == -1) {

src/main/java/de/zalando/sprocwrapper/proxy/StoredProcedureParameter.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)));
+    }
+}