最近在写一个项目，里面需要频繁使用反射操作。由于Java的反射API使用起来比较复杂，所以我决定把常用的反射操作封装成一个工具类：ReflectUtils。
在ReflectUtils中，有这么一个call方法：
public static <T> T call(Object obj, String methodName, Object... params);
这个方法利用反射调用某个实例对象的某个方法，obj是对象实例，methodName是方法名，params是传递给方法的参数。
最初这个方法是这么来实现的：
public static <T> T call(Object obj, String methodName, Object... params){ try { Method method = obj.getClass().getMethod(methodName, getTypes(params)); return (T) method.invoke(obj, params); } catch (Exception e) { throw new RuntimeException(e); }}
这个实现看起来很简单，只是把反射获取方法和调用方法的过程简单封装了一下，其中getTypes方法用于获取参数类型列表：
private static Class<?>[] getTypes(Object... params){ return Arrays.stream(params).map(Object::getClass).toArray(Class<?>[]::new);}
不过很快就发现了问题。假设我要调用某个String对象的substring方法：
String s1 = "hello";String s2 = ReflectUtils.call(s1, "substring", 1, 4);
预期s2的值应该为"ell"，但是上面的代码执行中却抛出了异常：
Exception in thread "main" java.lang.RuntimeException: java.lang.NoSuchMethodException: java.lang.String.substring(java.lang.Integer,java.lang.Integer)
从异常信息不难推断，String的substring方法的两个参数都是int类型，但是当我们把两个基本类型int通过Object...传入call时，int被包装成了Integer，与substring的参数类型不匹配。也就是说，凡是调用含有基本类型参数的函数，call函数都会失败。
这可怎么办呢？我想到了下面这个看起来十分"暴力"但是有用的解决方案：
public static <T> T call(Object obj, String methodName, Object... params){ try { Method method = obj.getClass().getMethod(methodName, getTypes(params)); return (T) method.invoke(obj, params); } catch (Exception e) { // 遍历obj中的每一个方法 for (Method method : obj.getClass().getMethods()) { try { // 筛选方法名和参数数量相同的方法 if (method.getName().equals(methodName) && method.getParameterCount() == params.length) return (T) method.invoke(obj, params); } catch (Exception ignored) {} } // 找不到方法 throw new RuntimeException(e); }}
简单地说，如果getMethod找不到匹配的方法，那么就直接遍历对象中所有方法名等于methodName且参数数量等于params长度的方法，并依次调用这些方法，如果调用成功就直接返回。
这个实现虽然看起来效率有点低，但是好歹能凑合使用，所以我使用了很长一段时间，直到遇到下面这个需求：
提前获取方法调用的返回值类型，而不实际调用这个方法。
例如，我想要知道将参数1和4（两个int类型的实参）传入String的substring方法后，方法返回值的类型：
Class<?> returnType = ReflectUtils.getReturnType(String.class, "substring", 1, 2);
上面代码的预期输出是String.class。
可以想象，这个getReturnType方法的签名一定是下面这样的：
public static Class<?> getReturnType(Class<?> type, String methodName, Object... params);
一个很容易想到的实现：
public static Class<?> getReturnType(Class<?> type, String methodName, Object... params){ try { Method method = type.getMethod(methodName, getTypes(params)); return method.getReturnType(); } catch (Exception e) { throw new RuntimeException(e); }}
事实上，这个实现是错误的，原因与上面的call方法类似。因为Java的自动装箱机制，当我们把两个int通过Object...传入时，int会被包装成Integer。getReturnType内部使用getMethod来查找方法，它实际执行的是下面这条语句：
type.getMethod("substring", Integer.class, Integer.class);
而不是我们期望的：
type.getMethod("substring", int.class, int.class);
当然什么也找不到了。万恶的自动装箱！
而且，在这种情况下，也不可能像call一样依次尝试调用type中的所有方法，因为我们仅仅只是想获取方法的返回值，而不希望真正调用这个方法。
下面记录一下我的解决方案。
首先在一个Map中存储基本类型与包装类型的对应关系：
private static final Map<Class<?>, Class<?>> primitiveAndWrap = new HashMap<>();static{ primitiveAndWrap.put(byte.class, Byte.class); primitiveAndWrap.put(short.class, Short.class); primitiveAndWrap.put(int.class, Integer.class); primitiveAndWrap.put(long.class, Long.class); primitiveAndWrap.put(float.class, Float.class); primitiveAndWrap.put(double.class, Double.class); primitiveAndWrap.put(char.class, Character.class); primitiveAndWrap.put(boolean.class, Boolean.class);}
isPrimitive方法用于判断一个类型是不是基本类型：
public static boolean isPrimitive(Class<?> type){ return primitiveAndWrap.containsKey(type);}
getWrap方法用于将基本类型转换为对应的包装类型：
public static Class<?> getWrap(Class<?> type){ if (!isPrimitive(type)) return type; return primitiveAndWrap.get(type);}
match方法用于判断actualType是否能被赋值给declaredType。注意，在进行isAssignableFrom判断前，使用getWrap抹平了基本类型与包装类型之间的差距：
private static boolean match(Class<?> declaredType, Class<?> actualType){ return getWrap(declaredType).isAssignableFrom(getWrap(actualType));}
进一步实现一个判断类型数组的match方法：
private static boolean match(Class<?>[]c1, Class<?>[] c2){ if (c1.length == c2.length) { for (int i = 0; i < c1.length; ++i) { if (!match(c1[i], c2[i])) return false; } return true; } return false;}
接着实现一个getMethod方法：
private static Method getMethod(Class<?> type, String name, Class<?>[] parameterTypes){ try { return type.getMethod(name, parameterTypes); } catch (Exception e) { for (Method method : type.getMethods()) { if (method.getName().equals(name) && method.getParameterCount() == parameterTypes.length) if (match(method.getParameterTypes(), parameterTypes)) return method; } throw new RuntimeException(e); }}
这个方法十分关键，它用来从某个类型中获取满足条件的方法。在getMethod内部，首先尝试用Class的getMethod来获取方法。如果获取不到，则遍历type中所有具有指定方法名和指定参数个数的方法，并判断该方法的参数类型是否与parameterTypes匹配（使用上面的match方法），即实参类型能否赋值给形参类型。
有了上面这些方法，就可以来实现getReturnType了：
public static Class<?> getReturnType(Class<?> type, String methodName, Object... params){ return getMethod(type, methodName, getTypes(params)).getReturnType();}
call的实现也可改写如下：
public static <T> T call(Object obj, String methodName, Object... params){ try { return (T) getMethod(obj.getClass(), methodName, getTypes(params)).invoke(obj, params); } catch (Exception e) { throw new RuntimeException(e); }}
ReflectUtils的完整代码：https://github.com/byx2000/ReflectUtils
原文转载：http://www.shaoqun.com/a/586579.html
跨境电商：https://www.ikjzd.com/
myshow：https://www.ikjzd.com/w/2235
shirley：https://www.ikjzd.com/w/1684
最近在写一个项目，里面需要频繁使用反射操作。由于Java的反射API使用起来比较复杂，所以我决定把常用的反射操作封装成一个工具类：ReflectUtils。在ReflectUtils中，有这么一个call方法：publicstatic<T>Tcall(Objectobj,StringmethodName,Object...params);这个方法利用反射调用某个实例对象的某个方法，ob
杨帆：https://www.ikjzd.com/w/1648
汇通天下：https://www.ikjzd.com/w/2055
亚马逊应用商店：https://www.ikjzd.com/w/531
阿里速卖通在俄推首个网上购车服务：https://www.ikjzd.com/home/18144
淡季如何做好速卖通数据化选品，引爆流量？：https://www.ikjzd.com/home/113544
作为一个有上进心的卖家，这个单刷还是不刷？：https://www.ikjzd.com/home/100879
