反射工具類：獲取到泛型對象的泛型類型 工具類： 使用方式： 附錄

工具類：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * 泛型工具類,用於獲取類對象綁定的泛型參數
 * @author skyfalling
 * @version 1.0.0
 */
public class Generics {

  /**
   * 查找類對象clazz綁定的genericClass聲明的泛型參數
   *
   * @param clazz        綁定泛型參數的類
   * @param genericClass 聲明泛型的類
   * @param index        泛型在聲明類中的索引位置
   * @return 如果綁定了泛型參數, 則返回泛型類型, 否則返回null
   */
  public static Class find(Class clazz, Class genericClass, int index) {
    if (!genericClass.isAssignableFrom(clazz)) {
      return null;
    }
    List<Type> types = getGenericTypes(clazz);
    for (Type type : types) {
      Class genericType = find(type, genericClass, index);
      if (genericType != null) {
        return genericType;
      }
    }
    return null;
  }

  /**
   * 查找類type上綁定的genericClass聲明的泛型類型
   *
   * @param type         泛型對象
   * @param genericClass 聲明泛型的類
   * @param index        泛型在聲明類中的索引位置
   * @return
   */
  private static Class find(Type type, Class genericClass, int index) {
    if (type instanceof Class) {
      return find((Class) type, genericClass, index);
    }
    if (type instanceof ParameterizedType) {
      ParameterizedType pType = (ParameterizedType) type;
      Type rawType = pType.getRawType();
      if (rawType instanceof Class) {
        Class rawClass = (Class) rawType;
        if (rawClass == genericClass) {
          Type realType = pType.getActualTypeArguments()[index];
          if (realType instanceof Class) {
            return (Class) realType;
          } else if (realType instanceof ParameterizedType) {
            //這裏是泛型的泛型
            return (Class) ((ParameterizedType) realType).getRawType();
          }
        } else if (genericClass.isAssignableFrom(rawClass)) {
          Map<String, Type> map = combine(pType.getActualTypeArguments(), rawClass);
          return find(rawClass, genericClass, index, map);
        }
      }
    }
    return null;
  }

  /**
   * 查找類currentClass上綁定的genericClass聲明的泛型類型
   *
   * @param currentClass 綁定泛型參數的類
   * @param genericClass 聲明泛型的類
   * @param index        泛型在聲明類中的索引位置
   * @param typeMap      已綁定的泛型類型映射表
   * @return
   */
  private static Class find(Class currentClass, Class genericClass, int index, Map<String, Type> typeMap) {
    List<Type> types = getGenericTypes(currentClass);
    for (Type type : types) {
      if (type instanceof ParameterizedType) {
        ParameterizedType pType = (ParameterizedType) type;
        Type rawType = pType.getRawType();
        if (rawType instanceof Class) {
          Class rawClass = (Class) rawType;
          Map<String, Type> map = transfer(pType, typeMap);
          Type[] typeArray = map.values().toArray(new Type[0]);
          if (rawClass == genericClass) {
            Type realType = typeArray[index];
            if (realType instanceof Class) {
              return (Class) realType;
            } else if (realType instanceof ParameterizedType) {
              //這裏是泛型的泛型
              return (Class) ((ParameterizedType) realType).getRawType();
            }
          } else if (genericClass.isAssignableFrom(rawClass)) {
            return find(rawClass, genericClass, index, combine(typeArray, rawClass));
          }
        }
      }
    }
    return null;
  }


  /**
   * 獲取當前類繼承的父類和實現接口的泛型列表
   *
   * @param clazz
   * @return
   */
  private static List<Type> getGenericTypes(Class clazz) {
    if (clazz == Object.class) {
      return Collections.EMPTY_LIST;
    }
    List<Type> list = new ArrayList<>();
    Type[] types = clazz.getGenericInterfaces();
    for (Type type : types) {
      list.add(type);
    }
    list.add(clazz.getGenericSuperclass());
    return list;
  }

  /**
   * 構建泛型映射表
   *
   * @param typeArguments 泛型參數
   * @param rawClass      聲明泛型的類
   * @return
   */
  private static Map<String, Type> combine(Type[] typeArguments, Class rawClass) {
    Map<String, Type> map = new LinkedHashMap<>(typeArguments.length);
    TypeVariable[] typeParameters = rawClass.getTypeParameters();
    for (int i = 0; i < typeParameters.length; i++) {
      map.put(typeParameters[i].getName(), typeArguments[i]);
    }
    return map;
  }


  /**
   * 轉換泛型映射表
   *
   * @param parameterizedType 綁定參數類型的泛型對象
   * @param typeMap           已綁定的泛型類型映射表
   * @return
   */
  private static Map<String, Type> transfer(ParameterizedType parameterizedType, Map<String, Type> typeMap) {

    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
    TypeVariable[] typeParameters = ((Class) parameterizedType.getRawType()).getTypeParameters();
    Map<String, Type> map = new LinkedHashMap<>();
    for (int i = 0; i < actualTypeArguments.length; i++) {
      Type type = actualTypeArguments[i];
      if (type instanceof TypeVariable) {
        String variableName = ((TypeVariable) type).getName();
        map.put(variableName, typeMap.get(variableName));
      } else {
        map.put(typeParameters[i].getName(), type);
      }
    }
    return map;
  }
}

使用方式：

定義泛型接口：

public interface Node<T, R> {
    R execute(T param);

    default Class<T> paramType() {
        return Generics.find(this.getClass(), Node.class, 0);
    }
}

定義泛型類：

public class MyNode implements Node<String, User> {
    @Override
    public User execute(String param) {

        Class<String> stringClass = paramType();

        System.out.println(stringClass);

        return null;
    }

    public static void main(String[] args) {
        MyNode myNode=new MyNode();
        myNode.execute("123");
    }

附錄

代碼來源的git地址