如何使用反射获取参数类型? [英] 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:
- 生成缓存密钥并查询HashMap或
- 迭代所有方法并查询参数兼容性
我的猜测:对于大类(许多方法),第一种方法将获胜,否则第二个将
My guess: for large classes (many methods), the first method will win, otherwise the second will
这篇关于如何使用反射获取参数类型?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!