Blogeek|Sioc

public interface I {}

public class B {}
public class C {}
public class A implements I<b> {}
I&lt;?&gt; a = new A();
I&lt;?&gt; b = new I {};</b>

Class<?> c1 = GenericsHelper.getInterfaceGenericType(A.class, I.class); // vaut B.class
Class<?> c2 = GenericsHelper.getInterfaceGenericType(a, I.class); // vaut B.class
Class<?> c3 = GenericsHelper.getInterfaceGenericType(b, I.class); // vaut C.class

interface I<T,U> {}
public class B {}
public class C {}
public class A implements I<B,C> {}
Class<?> c1 = GenericsHelper.getInterfaceGenericType(A.class, I.class, 0); // vaut B.class
Class<?> c2 = GenericsHelper.getInterfaceGenericType(A.class, I.class, 1); // vaut C.class
Class<?> c3 = GenericsHelper.getInterfaceGenericType(A.class, I.class); // vaut B.class, n°0 par défaut

import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.Stack;
 
/**
 * Classe helper pour déterminer les types concrets des variables génériques définies dans des interfaces.
 * @author fguerry
 */
public class GenericsHelper {
 
    // constructeur privé = class util
    private GenericsHelper() {
    }
 
    /**
     *

     *

     * @param instance
     * @param interf
     * @return 
     */
    public static Class<?> getInterfaceGenericType(Object instance, Class<?> interf) {
        return getInterfaceGenericType(instance.getClass(), interf, 0);
    }
 
    /**
     *

     *

     * @param instance
     * @param interf
     * @param typeNumber
     * @return 
     */
    public static Class<?> getInterfaceGenericType(Object instance, Class<?> interf, int typeNumber) {
        return getInterfaceGenericType(instance.getClass(), interf, typeNumber);
    }
 
    /**
     *

     *

     * @param implementor
     * @param interf
     * @return 
     */
    public static Class<?> getInterfaceGenericType(Class<?> implementor, Class<?> interf) {
        return getInterfaceGenericType(implementor, interf, 0);
    }
 
    /**
     *

     *

     * @param implementor
     * @param interf
     * @param typeNumber
     * @return 
     */
    public static Class<?> getInterfaceGenericType(final Class<?> implementor, Class<?> interf, int typeNumber) {
        if (implementor == null) {
            throw new NullPointerException("The given implementor class must not be null.");
        }
        if (interf == null) {
            throw new NullPointerException("The given generic interface must not be null.");
        }
        if (typeNumber < 0) {
            throw new IllegalArgumentException("The given typeNumber must not be negative.");
        }
        if (implementor.isInterface()) {
            throw new IllegalArgumentException("The given implementor class " + implementor.getCanonicalName() + " is actually an interface !");
        }
        if (Modifier.isAbstract(implementor.getModifiers())) {
            throw new IllegalArgumentException("The given implementor class " + implementor.getCanonicalName() + " is actually abstract and cannot be looked for implemented interface generic types !");
        }
        if (!interf.isInterface()) {
            throw new IllegalArgumentException("The given interface " + interf.getCanonicalName() + " is actually NOT an interface !");
        }
        Stack<Class<?>> parentStack = new Stack<Class<?>>();
        TypeVariable<?> backSearch = null;
        Class<?> currentClass = implementor;
        implWhile:
        while (currentClass != null) {
            // première passe : on cherche si l'interface est effectivement implémentée dans la classe, et si la variable est spécifiée
            // directement dans la déclaration implements d'une des classes de la hiérarchie
            final Type[] interfaces = currentClass.getGenericInterfaces();
            for (int index = 0; index < interfaces.length; index++) {
                ParameterizedType param = (ParameterizedType) interfaces[index];
                if (param.getRawType().equals(interf)) {
                    final Type[] actualTypeArguments = param.getActualTypeArguments();
                    if (typeNumber >= actualTypeArguments.length) {
                        throw new IllegalArgumentException("The given interface " + interf.getCanonicalName() + " doesn't have a n°" + typeNumber + " parameterizd type, but has only " + actualTypeArguments.length + " of them");
                    }
                    final Type name = actualTypeArguments[typeNumber];
                    if (name instanceof Class) {
                        // la variable est définie à ce niveau directement, ça veut dire que la clause implements a spécifié des types concrets
                        return (Class) name;
                    } else if (name instanceof TypeVariable) {
                        // sinon, la variable a été transmise à la déclaration de la classe, on passe donc à la phase 2
                        backSearch = (TypeVariable) name;
                        break implWhile;
                    }
                }
            }
            parentStack.push(currentClass);
            currentClass = currentClass.getSuperclass();
        }
        while (backSearch != null) {
            // phase 2 : on redescend la hierarchie grâce à la stack afin de déterminer sur quelle classe la viariable est définie
            final int index = indexOfTypeVariable(currentClass, backSearch);
            if (parentStack.isEmpty()) {
                // si à un moment donné on ne peut plus descendre et que la variable n'est toujours pas définie, cela
                // signifie qu'elle est définie nulle part... on ne peut donc pas donner de résultat !
                throw new IllegalArgumentException("The generic parameter n°" + typeNumber + " of interface " + interf.getCanonicalName() + " is not bound anywhere into class " + implementor.getCanonicalName() + ". You should create a fully typed subclass of this class to be able to use this function !!");
            }
            currentClass = parentStack.pop();
            ParameterizedType superclassbound = (ParameterizedType) currentClass.getGenericSuperclass();
            final Type name = superclassbound.getActualTypeArguments()[index];
            if (name instanceof Class) {
                // si la variable est définie à ce niveau, on s'arrête
                return (Class) name;
            } else if (name instanceof TypeVariable) {
                // sinon on continue de descendre
                backSearch = (TypeVariable) name;
            }
        }
        throw new IllegalArgumentException("The given class " + implementor.getCanonicalName() + " doesn't implements the given interface " + interf.getCanonicalName());
    }
 
    /**
     * Retrouve l'index d'une variable générique donnée dans la déclaration d'une classe donnée.
     * @param implementor
     * @param var
     * @return 
     */
    public static int indexOfTypeVariable(Class<?> implementor, TypeVariable<?> var) {
        final TypeVariable<?>[] parameters = implementor.getTypeParameters();
        for (int index = 0; index < parameters.length; index++) {
            if (parameters[index].equals(var)) {
                return index;
            }
        }
        return -1;
    }
}