0

在我的例子中，我想知道Guavaapply接口的给定实现的方法参数是否被注释。实现方法： Function@Nullable

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

我不知道如何从类中获取实现apply的方法。function

例如，可能有这样的Function实现：

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

3 回答 3

2

这是一个快速而肮脏的解决方案。不要直接复制和粘贴它——它只是作为一个例子来帮助你入门。

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.");
}

实际上，您需要分别对各种问题进行编码：

  • 在实现类型上找到泛型接口
  • 查找F泛型接口的类型参数
  • 查找apply实施
  • 检查给定注释的参数

正如代码中所指出的，对于更复杂的类型层次结构，此解决方案很容易中断，例如：

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

Anew LongFunction<String> { }将是 aFunction<Long, String>但上述方法不会将泛型Function接口定位在其运行时类型上。

于 2013-09-12T02:44:30.780 回答
2

解决方案是：

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;
    }
}

commons-lang3 3.1 版本中的 TypeUtils.getTypeArguments 有一个错误，但在 3.2 中已修复，目前正在开发中。

于 2013-09-12T02:54:13.227 回答
1

如果我的问题是正确的，那么您想对 apply 方法中的注释进行一些验证。在这种情况下，您需要使用反射（特别是这种方法）。它会是这样的（我将制作一个省略例外的草稿）：

this.getClass().getMethod("apply", parameter.getClass()).getParameterAnnotations()
于 2013-09-12T00:04:57.500 回答