Question

我想获取方法返回类型的String表示形式，该返回类型带有类型参数，但没有包名称，例如“ List”。

从返回类型的类对象中，我们可以通过method.getReturnType().getSimpleName()获得没有包前缀的简单名称，但没有泛型类型参数。输出：List

也可以通过method.getGenericReturnType().toString()获得长格式的泛型类型参数。输出：java.util.collections.List<java.util.String>

但是如何获得带有泛型类型参数的简单名称？

例如：List<String>代替java.util.collections.List<java.util.String>

Answer 1

您可以使用以下简单方法遍历类型树：

  static String simpleTypeName(Type t) {
    if (t instanceof ParameterizedType) {
      ParameterizedType p = (ParameterizedType) t;
      return simpleTypeName(p.getRawType())
          + Stream.of(p.getActualTypeArguments())
              // Recurse to handle the type arguments.
              .map(YourClass::simpleTypeName)
              .collect(Collectors.joining(", ", "<", ">"));
    } else if (t instanceof Class) {
      Class<?> c = (Class<?>) t;
      return c.getSimpleName();
    } else {
      // ... handle other Type subtypes.
    }
  }

并像这样调用：

String typeName = simpleTypeName(yourMethod.getGenericReturnType());

Ideone demo

Answer 2

您需要编写简单的类来递归遍历类型并在每个级别上生成简单的名称：

class TypeSimpleName {

    private final Type value;

    public TypeSimpleName(Type value) {
        this.value = value;
    }

    public String getName() {
        return getName(value);
    }

    private String getName(Type type) {
        if (type instanceof ParameterizedType) {
            return getParameterizedTypeName((ParameterizedType) type);
        }
        if (type instanceof Class) {
            return getClassSimpleName(type);
        }
        // handle other types if needed

        return type.getTypeName();
    }

    private String getParameterizedTypeName(ParameterizedType type) {
        StringBuilder builder = new StringBuilder();

        builder.append(getName(type.getRawType()));
        Type[] typeArguments = type.getActualTypeArguments();
        if (typeArguments.length > 0) {
            builder.append("<");
            for (int i = 0; i < typeArguments.length; i++) {
                Type arg = typeArguments[i];
                builder.append(getName(arg));
                if (i < typeArguments.length - 1) {
                    builder.append(", ");
                }
            }
            builder.append(">");
        }

        return builder.toString();
    }

    private String getClassSimpleName(Type type) {
        return ((Class) type).getSimpleName();
    }

    @Override
    public String toString() {
        return getName();
    }
}

如何使用它：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.springframework.util.ReflectionUtils;

public class Test {

    public static void main(String[] args) {
        System.out.println(getReturnTypeName("getList"));
        System.out.println(getReturnTypeName("getListList"));
        System.out.println(getReturnTypeName("getObj"));
        System.out.println(getReturnTypeName("getMapMap"));
    }

    private static String getReturnTypeName(String method) {
        Type returnType = ReflectionUtils.findMethod(Test.class, method).getGenericReturnType();

        return new TypeSimpleName(returnType).getName();
    }

    public List<String> getList() {
        return null;
    }

    public List<List<String>> getListList() {
        return null;
    }

    public Integer getObj() {
        return 1;
    }

    public Map<String, Map<Integer, BigDecimal>> getMapMap() {
        return null;
    }
}

上面的代码显示：

List<String>
List<List<String>>
Integer
Map<String, Map<Integer, BigDecimal>>

如何获得简单的泛型类型名称？

2 个答案: