如何获取间接实现的通用接口的实际类型参数?

时间:2010-12-23 08:08:53

标签: java generics reflection interface

我有一个参数化界面,它以多种不同的方式实现。在运行时,我需要弄清楚,给定一个实现该接口的任意对象,接口的实际类型参数是什么。

这是一个用来说明问题的片段,以及解决问题的中途尝试(also on ideone.com):

import java.util.*;
import java.lang.reflect.*;

interface Awesome<X> { }
class Base<E> implements Awesome<Set<E>> { }
class Child extends Base<List<Integer>> { }

class AwesomeExample {      
    public static void main(String[] args) {
        Awesome<Set<List<Integer>>> x = new Child();

        System.out.println(
            ((ParameterizedType)
                Child.class.getGenericSuperclass()
            ).getActualTypeArguments()[0]
        );
        // prints "java.util.List<java.lang.Integer>"

        System.out.println(
            ((ParameterizedType)
                Base.class.getGenericInterfaces()[0]
            ).getActualTypeArguments()[0]
        );
        // prints "java.util.Set<E>"        

        investigate(x);
        // we want this to print "Set<List<Integer>>"
    }

    static void investigate(Awesome<?> somethingAwesome) {
        // how to do this?
    }
}

在运行时看起来有足够的泛型类型信息来推断:

  • Child extends Base<List<Integer>>
  • Base<E> implements Awesome<Set<E>>

因此,我们可以把所有的点点滴滴汇总在一起得出结论:

  • Child implements Awesome<Set<List<Integer>>>

所以看起来这个问题是可以解决的,但并不是那么简单,因为我们必须使用任意的类/接口层次结构。这是唯一的方法吗?有更简单的方法吗?有人写过图书馆吗?

3 个答案:

答案 0 :(得分:4)

编辑:您可能只想查看使用:http://code.google.com/p/gentyref/

如果你可以保证Awesome<?>的所有实现都没有类型参数,那么下面的代码应该让你开始[1]:

static void investigate(Object o) {
    final Class<?> c = o.getClass();
    System.out.println("\n" + c.getName() + " implements: ");
    investigate(c, (Type[])null);
}

static void investigate(Type t, Type...typeArgs) {
    if(t == null) return;

    if(t instanceof Class<?>) {
        investigate((Class<?>)t, typeArgs);
    } else if(t instanceof ParameterizedType) {
        investigate((ParameterizedType)t, typeArgs);
    }
}

static void investigate(Class<?> c, Type...typeArgs) {
    investigate(c.getGenericSuperclass(), typeArgs);

    for(Type i : c.getGenericInterfaces()) {
        investigate(i, typeArgs);
    }
}

static void investigate(ParameterizedType p, Type...typeArgs) {
    final Class<?> c = (Class<?>)p.getRawType();
    final StringBuilder b = new StringBuilder(c.getName());
    b.append('<');
    Type[] localArgs = p.getActualTypeArguments();
    if(typeArgs != null && typeArgs.length > 0) {
        int i = 0, nextTypeArg = 0;
        for(Type local : localArgs) {
            if(local instanceof ParameterizedType) {
                ParameterizedType localP = (ParameterizedType) local;
                b.append(localP.getRawType()).append('<');
                b.append(typeArgs[nextTypeArg++]);
                b.append('>');
            } else if(local instanceof TypeVariable) {
                // reify local type arg to instantiated one.
                localArgs[nextTypeArg] = typeArgs[nextTypeArg];
                b.append(localArgs[nextTypeArg]);
                nextTypeArg++;
            } else {
                b.append(local.toString());
            }
            b.append(", ");
            i++;
        }
        if(typeArgs.length > 0) {
            b.delete(b.length() - 2, b.length());
        }
        b.append('>');
    } else {
        String args = Arrays.toString(localArgs);
        b.append(args.substring(1, args.length()-1)).append('>');
    }
    System.out.println(b);
    investigate(c, localArgs);
}

但是,如果要进行Awesome<?>Base<E>的实例化,则该类型信息将因擦除而丢失。作为惯例,这可以通过以下方式解决:

Awesome<?> awesome = new Base<Double>() {};

注意{},这会创建一个新的匿名类来实现(或扩展)Base<E>。该类的类型参数可用于反射。

如果您害怕执行此约定将是一个问题,您可以隐藏构造函数&amp;只暴露工厂方法:

class Base<E> implements Awesome<Set<E>> {

    public static Base<Number> newNumberInstance() {
        return new Base<Number> () {};
    }

    protected Base() {}
}

由于上述代码尚未经过全面测试,您可能希望这样做。这里的要点是,鉴于您的要求非常严格,您可以找到实际的类型参数。是否适用于您的情况取决于您。

[1]它将打印出一个类实现的所有接口。不只是Awesome的类型参数。这可以改变,但我想我会选择更普遍的&amp;让你弄清楚具体细节。例如,您需要测试这些以查看我的意思:

investigate(new ArrayList<Integer>());
investigate(new ArrayList<String>() {}); // new anonymous ArrayList class
investigate("");
investigate(new Awesome<Comparable<?>> () {}); // new anonymous implementation of Awesome

答案 1 :(得分:1)

根据@ oconnor0的提议,以下是gentyref的使用方法:

static Type investigate(Awesome<?> somethingAwesome) {
    return GenericTypeReflector.getTypeParameter(somethingAwesome.getClass(), Awesome.class.getTypeParameters()[0]);
}

如果somethingAwesome.getClass()也可以是通用的,那么首先通过GenericTypeReflector.addWildcardParameters传递它可能会很有用。

Spring还有一个GenericTypeResolver.resolveTypeArgument(Class,Class)可以达到相同的效果。

答案 2 :(得分:-1)

简短的回答是否定的。我同意这很可惜...... :( 原因是Java在编译阶段丢弃了类型参数。它们不存在于字节代码中。它们仅由编译器使用。

要解决您的问题,您必须添加另一个类型为Class的“常规”参数,并在创建Base实例时将其传递给构造函数:

class Base<E> implements Awesome<Set<E>> { 
    private E type;
    public Base(E type) {
        this.type = type;
    }
}