如何获取Java中通用接口实现的方法对象

Question

In my case I want to find out if apply method's parameter for given implementation of Guava Function interface is annotated @Nullable . Method to be implemented:

boolean isNullableArgument(Class<? extends Function<?,?>> function);

I don't know how to get implemented apply method from function class.

---

Eg there could be Function implementations like this:

new Function<String,Integer>() {
    public Integer apply(String input) { … }
    public Integer apply(Integer input) { … }
}

Answer 1

Here's a quick and dirty solution. Don't copy and paste it directly - it's only meant as an example to get you started.

static boolean applyHasAnnotation(
        @SuppressWarnings("rawtypes") final Class<? extends Function> functionType,
        final Class<? extends Annotation> annotationType
) throws SecurityException, NoSuchMethodException {
    //for each directly implemented interface,
    for (final Type interfaceType : functionType.getGenericInterfaces()) {
        //if the interface is parameterized,
        if (interfaceType instanceof ParameterizedType) {
            final ParameterizedType genericInterfaceType = (ParameterizedType)interfaceType;
            //if the interface is Function
            if (genericInterfaceType.getRawType() == Function.class) {
                //get the type argument for T
                final Type inputType = genericInterfaceType.getActualTypeArguments()[0];
                //get its raw type
                final Class<?> rawInputType =
                        (inputType instanceof ParameterizedType)
                        ? (Class<?>)((ParameterizedType)inputType).getRawType()
                        : (Class<?>)inputType;
                //use it to find the apply implementation
                final Method applyMethod = functionType.getDeclaredMethod("apply", rawInputType);
                //for each annotation on its first (and only) parameter,
                for (final Annotation inputAnnotation : applyMethod.getParameterAnnotations()[0]) {
                    //if its type is the specified annotation type, return true
                    if (inputAnnotation.annotationType() == annotationType) {
                        return true;
                    }
                }
                return false;
            }
        }
    }
    //a more complicated inheritance hierarchy has defeated us
    throw new IllegalArgumentException("Function info not found.");
}

In actuality, you'll want to code the various concerns separately:

• finding the generic interface on the implementing type
• looking up the F type argument to the generic interface
• looking up the apply implementation
• checking its parameter for a given annotation

As pointed out in the code, this solution easily breaks for more complicated type hierarchies, for example:

abstract class LongFunction<T> implements Function<Long, T> { }

A new LongFunction<String> { } would be a Function<Long, String> but the above method would not location the generic Function interface on its runtime type.

Answer 2

The solution is:

import com.google.common.base.Function;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.Map;
import javax.annotation.Nullable;
import org.apache.commons.lang3.reflect.TypeUtils;

public class FunkUtils { private FunkUtils() {}

    public static boolean isNullableArgument(Class<? extends Function> functionClass) throws Exception {
        Map<TypeVariable<?>,Type> typeArgs = TypeUtils.getTypeArguments(functionClass, Function.class);
        TypeVariable<?> argTypeParam = Function.class.getTypeParameters()[0];
        Type argType = typeArgs.get(argTypeParam);
        Class argClass = TypeUtils.getRawType(argType, null);
        Method applyMethod = functionClass.getDeclaredMethod("apply", argClass);
        Annotation[] argAnnos = applyMethod.getParameterAnnotations()[0];
        for (int i = 0; i < argAnnos.length; i++) {
            if (argAnnos[i] instanceof Nullable) return true;
        }
        return false;
    }
}

---

There is a bug in TypeUtils.getTypeArguments in commons-lang3 version 3.1, but it is fixed in 3.2, that is under development now.

Answer 3

If I got you question right, you want to do some validation of the annotation in the apply method. You would need to use reflection this case (specially this method ). It would be something like (I will just make a draft omitting the exceptions):

this.getClass().getMethod("apply", parameter.getClass()).getParameterAnnotations()