#321 follow-up. Added GenericArrayType support.

Author: harawata

src/main/java/org/apache/ibatis/reflection/TypeParameterResolver.java

@@ -15,6 +15,8 @@
  */
 package org.apache.ibatis.reflection;
 
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
@@ -38,12 +40,31 @@ public static Type resolveReturnType(Method method, Type mapper) {
       result = resolveTypeVar((TypeVariable<?>) returnType, mapper, declaringClass);
     } else if (returnType instanceof ParameterizedType) {
       result = resolveParameterizedType((ParameterizedType) returnType, mapper, declaringClass);
+    } else if (returnType instanceof GenericArrayType) {
+      result = resolveGenericArrayType((GenericArrayType) returnType, mapper, declaringClass);
     } else {
       result = returnType;
     }
     return result;
   }
 
+  private static Type resolveGenericArrayType(GenericArrayType genericArrayType, Type mapper, Class<?> declaringClass) {
+    Type componentType = genericArrayType.getGenericComponentType();
+    Type resolvedComponentType = null;
+    if (componentType instanceof TypeVariable) {
+      resolvedComponentType = resolveTypeVar((TypeVariable<?>) componentType, mapper, declaringClass);
+    } else if (componentType instanceof GenericArrayType) {
+      resolvedComponentType = resolveGenericArrayType((GenericArrayType) componentType, mapper, declaringClass);
+    } else if (componentType instanceof ParameterizedType) {
+      resolvedComponentType = resolveParameterizedType((ParameterizedType) componentType, mapper, declaringClass);
+    }
+    if (resolvedComponentType instanceof Class) {
+      return Array.newInstance((Class<?>) resolvedComponentType, 0).getClass();
+    } else {
+      return new GenericArrayTypeImpl(resolvedComponentType);
+    }
+  }
+
   private static ParameterizedType resolveParameterizedType(ParameterizedType parameterizedType, Type mapper, Class<?> declaringClass) {
     Class<?> rawType = (Class<?>) parameterizedType.getRawType();
     Type[] typeArgs = parameterizedType.getActualTypeArguments();
@@ -193,4 +214,18 @@ public Type[] getUpperBounds() {
       return upperBounds;
     }
   }
+
+  static class GenericArrayTypeImpl implements GenericArrayType {
+    private Type genericComponentType;
+
+    private GenericArrayTypeImpl(Type genericComponentType) {
+      super();
+      this.genericComponentType = genericComponentType;
+    }
+
+    @Override
+    public Type getGenericComponentType() {
+      return genericComponentType;
+    }
+  }
 }

src/test/java/org/apache/ibatis/reflection/TypeParameterResolverTest.java

@@ -17,6 +17,7 @@
 
 import static org.junit.Assert.*;
 
+import java.lang.reflect.GenericArrayType;
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
@@ -116,6 +117,18 @@ public void testReturn_SimpleArray() throws Exception {
     assertEquals(String.class, resultClass.getComponentType());
   }
 
+  @Test
+  public void testReturn_SimpleArrayOfArray() throws Exception {
+    Class<?> clazz = Level1Mapper.class;
+    Method method = clazz.getMethod("simpleSelectArrayOfArray");
+    Type result = TypeParameterResolver.resolveReturnType(method, clazz);
+    assertTrue(result instanceof Class);
+    Class<?> resultClass = (Class<?>) result;
+    assertTrue(resultClass.isArray());
+    assertTrue(resultClass.getComponentType().isArray());
+    assertEquals(String.class, resultClass.getComponentType().getComponentType());
+  }
+
   @Test
   public void testReturn_SimpleTypeVar() throws Exception {
     Class<?> clazz = Level1Mapper.class;
@@ -188,6 +201,43 @@ public void testReturn_Lv1List() throws Exception {
     assertEquals(String.class, type.getActualTypeArguments()[0]);
   }
 
+  @Test
+  public void testReturn_Lv1Array() throws Exception {
+    Class<?> clazz = Level1Mapper.class;
+    Method method = clazz.getMethod("selectArray");
+    Type result = TypeParameterResolver.resolveReturnType(method, clazz);
+    assertTrue(result instanceof Class);
+    Class<?> resultClass = (Class<?>) result;
+    assertTrue(resultClass.isArray());
+    assertEquals(String.class, resultClass.getComponentType());
+  }
+
+  @Test
+  public void testReturn_Lv2ArrayOfArray() throws Exception {
+    Class<?> clazz = Level2Mapper.class;
+    Method method = clazz.getMethod("selectArrayOfArray");
+    Type result = TypeParameterResolver.resolveReturnType(method, clazz);
+    assertTrue(result instanceof Class);
+    Class<?> resultClass = (Class<?>) result;
+    assertTrue(result instanceof Class);
+    assertTrue(resultClass.isArray());
+    assertTrue(resultClass.getComponentType().isArray());
+    assertEquals(String.class, resultClass.getComponentType().getComponentType());
+  }
+
+  @Test
+  public void testReturn_Lv2ArrayOfList() throws Exception {
+    Class<?> clazz = Level2Mapper.class;
+    Method method = clazz.getMethod("selectArrayOfList");
+    Type result = TypeParameterResolver.resolveReturnType(method, clazz);
+    assertTrue(result instanceof GenericArrayType);
+    GenericArrayType genericArrayType = (GenericArrayType) result;
+    assertTrue(genericArrayType.getGenericComponentType() instanceof ParameterizedType);
+    ParameterizedType paramType = (ParameterizedType) genericArrayType.getGenericComponentType();
+    assertEquals(List.class, paramType.getRawType());
+    assertEquals(String.class, paramType.getActualTypeArguments()[0]);
+  }
+
   @Test
   public void testReturn_Lv2WildcardList() throws Exception {
     Class<?> clazz = Level2Mapper.class;

src/test/java/org/apache/ibatis/reflection/typeparam/Level0Mapper.java

@@ -32,6 +32,8 @@ public interface Level0Mapper<L, M, N> {
 
   String[] simpleSelectArray();
 
+  String[][] simpleSelectArrayOfArray();
+
   <K extends Calculator<?>> K simpleSelectTypeVar();
 
   List<? extends String> simpleSelectWildcard();
@@ -44,6 +46,12 @@ public interface Level0Mapper<L, M, N> {
 
   Map<N, M> selectMap();
 
+  N[] selectArray();
+
+  N[][] selectArrayOfArray();
+
+  List<N>[] selectArrayOfList();
+
   Calculator<N> selectCalculator(Calculator<N> param);
 
   List<Calculator<L>> selectCalculatorList();