Java 8 Lambdas 上的反射类型推理

我正在Java 8中试验新的Lambdas，我正在寻找一种方法来使用lambda类上的反射来获得lambda函数的返回类型。我对 lambda 实现通用超接口的情况特别感兴趣。在下面的代码示例中，是泛型超接口，我正在寻找一种方法来找出哪种类型绑定到泛型参数。MapFunction<F, T>T

虽然Java在编译器之后丢弃了大量的泛型类型信息，但泛型超类和泛型超接口的子类（和匿名子类）确实保留了该类型信息。通过反射，这些类型是可访问的。在下面的示例（案例 1）中，反射告诉我，绑定到泛型类型参数 的实现。MyMapperMapFunctionjava.lang.IntegerT

即使对于本身就是泛型的子类，如果其他一些子类是已知的，也有一些方法可以找出绑定到泛型参数的子类。考虑以下示例中的情况 2，其中两者绑定到同一类型。当我们知道这一点时，如果我们知道参数类型，我们就知道类型（在我的情况下，我们知道）。IdentityMapperFTFT

现在的问题是，我如何才能为Java 8 lambdas实现类似的东西？由于它们实际上不是泛型超接口的常规子类，因此上述方法不起作用。具体来说，我能弄清楚绑定到 和 绑定与 和 相同吗？parseLambdajava.lang.IntegerTidentityLambdaFT

PS：从理论上讲，应该可以反编译lambda代码，然后使用嵌入式编译器（如JDT）并利用其类型推断。我希望有一种更简单的方法可以做到这一点;-）

/**
 * The superinterface.
 */
public interface MapFunction<F, T> {

    T map(F value);
}

/**
 * Case 1: A non-generic subclass.
 */
public class MyMapper implements MapFunction<String, Integer> {

    public Integer map(String value) {
        return Integer.valueOf(value);
    }
}

/**
 * A generic subclass
 */
public class IdentityMapper<E> implements MapFunction<E, E> {

    public E map(E value) {
        return value;
    }

}

/**
 * Instantiation through lambda
 */

public MapFunction<String, Integer> parseLambda = (String str) -> { return Integer.valueOf(str); }

public MapFunction<E, E> identityLambda = (value) -> { return value; }


public static void main(String[] args)
{
    // case 1
    getReturnType(MyMapper.class);    // -> returns java.lang.Integer

    // case 2
    getReturnTypeRelativeToParameter(IdentityMapper.class, String.class);    // -> returns java.lang.String
}

private static Class<?> getReturnType(Class<?> implementingClass)
{
    Type superType = implementingClass.getGenericInterfaces()[0];

    if (superType instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) superType;
        return (Class<?>) parameterizedType.getActualTypeArguments()[1];
    }
    else return null;
}

private static Class<?> getReturnTypeRelativeToParameter(Class<?> implementingClass, Class<?> parameterType)
{
    Type superType = implementingClass.getGenericInterfaces()[0];

    if (superType instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) superType;
        TypeVariable<?> inputType = (TypeVariable<?>) parameterizedType.getActualTypeArguments()[0];
        TypeVariable<?> returnType = (TypeVariable<?>) parameterizedType.getActualTypeArguments()[1];

        if (inputType.getName().equals(returnType.getName())) {
            return parameterType;
        }
        else {
            // some logic that figures out composed return types
        }
    }

    return null;
}