如何使用反射获取参数类型？ [英] How to get parameter types using reflection?

问题描述

我想使用具有不同数量参数的函数。问题是我不知道每个函数的参数数量，而且我不知道函数的名称，因为它们存储在数组中。我只知道类名，但不想使用 getDeclaredMethods 因为它会增加搜索时间。有没有办法获取每个函数的参数类型？

I want to use functions having different numbers of parameters. The problem is that I don't know the number of parameters of each function, and also I don't know names of function as they are stored in an array. I only knows the class name, but don't want to use getDeclaredMethods as it will increase search time. Is there a way to get the parameter types for each function?

推荐答案

我必须查找方法时通常做的是从我正在进行的查询生成缓存键，并将此缓存键保存在地图中的搜索结果。

What I usually do when I have to look up methods is to generate a cache key from the query I am doing and save the search result with this cache key in a map.

示例：

我知道方法参数是 Boolean.TRUE ， Arrays.asList（foo，bar，baz ）和 BigInteger.valueOf（77777l）

I know the method parameters are Boolean.TRUE, Arrays.asList("foo","bar","baz") and BigInteger.valueOf(77777l)

我的类包含一个方法签名

My class contains a method with the signature

public foo(boolean, Collection, Number)

我无法直接将参数映射到参数类型，因为我只是不知道哪个超类或接口是参数类型，你可以从中看到下表：

There's no way I can directly map the parameters to the parameter types because I just don't know which of the super classes or interfaces is the parameter type as you can see from the following table:

Expected Type          |  What I have
-----------------------------------------------------
 boolean               |  java.lang.Boolean
 java.util.Collection  |  java.util.Arrays$ArrayList
 java.lang.Number      |  java.math.BigInteger

这些对中的每一对都是兼容的，但是无法找到兼容的方法没有定义比较方法，如下所示：

Each of these pairs is compatible, but there's no way to find the compatible method without defining a comparison method, something like this:

// determine whether a method's parameter types are compatible
// with my arg array
public static boolean isCompatible(final Method method,
    final Object[] params) throws Exception{
    final Class<?>[] parameterTypes = method.getParameterTypes();
    if(params.length != parameterTypes.length){
        return false;
    }
    for(int i = 0; i < params.length; i++){
        final Object object = params[i];
        final Class<?> paramType = parameterTypes[i];
        if(!isCompatible(object, paramType)){
            return false;
        }
    }
    return true;
}

// determine whether a single object is compatible with
// a single parameter type
// careful: the object may be null
private static boolean isCompatible(final Object object,
    final Class<?> paramType) throws Exception{
    if(object == null){
        // primitive parameters are the only parameters
        // that can't handle a null object
        return !paramType.isPrimitive();
    }
    // handles same type, super types and implemented interfaces
    if(paramType.isInstance(object)){
        return true;
    }
    // special case: the arg may be the Object wrapper for the
    // primitive parameter type
    if(paramType.isPrimitive()){
        return isWrapperTypeOf(object.getClass(), paramType);
    }
    return false;

}

/*
  awful hack, can be made much more elegant using Guava:

  return Primitives.unwrap(candidate).equals(primitiveType);

*/
private static boolean isWrapperTypeOf(final Class<?> candidate,
    final Class<?> primitiveType) throws Exception{
    try{
        return !candidate.isPrimitive()
            && candidate
                .getDeclaredField("TYPE")
                .get(null)
                .equals(primitiveType);
    } catch(final NoSuchFieldException e){
        return false;
    } catch(final Exception e){
        throw e;
    }
}

所以我要做的是有一个方法缓存：

So what I'd do is have a method cache:

private static final Map<String, Set<Method>> methodCache;

并添加如下查找方法：

public static Set<Method> getMatchingMethods(final Class<?> clazz,
    final Object[] args) throws Exception{
    final String cacheKey = toCacheKey(clazz, args);
    Set<Method> methods = methodCache.get(cacheKey);
    if(methods == null){
        final Set<Method> tmpMethods = new HashSet<Method>();
        for(final Method candidate : clazz.getDeclaredMethods()){
            if(isCompatible(candidate, args)){
                tmpMethods.add(candidate);
            }
        }
        methods = Collections.unmodifiableSet(tmpMethods);
        methodCache.put(cacheKey, methods);
    }
    return methods;
}

private static String toCacheKey(final Class<?> clazz, final Object[] args){
    final StringBuilder sb = new StringBuilder(clazz.getName());
    for(final Object obj : args){
        sb.append('-').append(
            obj == null ? "null" : obj.getClass().getName());
    }
    return sb.toString();
}

这样，后续查找所花的时间比第一次少得多（对于相同类型的参数）。

That way, subsequent lookups will take much less time than the first one (for parameters of the same type).

当然，因为 Class.getDeclaredMethods（）在内部使用缓存，所以问题是我的缓存是否提高了性能。这基本上是一个更快的问题：

Of course since Class.getDeclaredMethods() uses a cache internally, the question is whether my cache improves performance at all. It's basically a question of what's faster:

1. 生成缓存密钥并查询HashMap或


2. 迭代所有方法并查询参数兼容性

我的猜测：对于大类（许多方法），第一种方法将获胜，否则第二个将

My guess: for large classes (many methods), the first method will win, otherwise the second will

这篇关于如何使用反射获取参数类型？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！