Question

java.lang.reflect.Method.invoke()文档说明它会抛出IllegalArgumentException

IllegalArgumentException - 如果方法是实例方法，并且指定的对象参数不是声明底层方法（或其子类或实现者）的类或接口的实例;如果实际参数和形式参数的数量不同;如果原始参数的展开转换失败;或者，如果在可能的解包后，参数值无法通过方法调用转换转换为相应的形式参数类型。

有没有办法测试方法是否在不调用它的情况下为给定的参数抛出IllegalArgumentException？

Answer 1

可以手动检查实例，方法和参数数量的正确性，并通过搭载本机java机制来检查参数的可赋值性。

public class Methods {
  public static boolean isInvocable(Method method, Object instance,
      Object... arguments) {
    return correctInstance(instance, method)
        && correctArguments(arguments, method);
  }

  private static boolean correctInstance(Object instance, Method method) {
    return Modifier.isStatic(method.getModifiers())
        || method.getDeclaringClass().isInstance(instance);
  }

  private static boolean correctArguments(Object[] arguments, Method method) {
    Class<?>[] parameters = method.getParameterTypes();
    if (parameters.length != arguments.length) {
      return false;
    }
    for (int i = 0; i < parameters.length; i++) {
      if (!correctArgument(arguments[i], parameters[i])) {
        return false;
      }
    }
    return true;
  }

  private static boolean correctArgument(Object instance, Class<?> type) {
    return type.isPrimitive()
        ? correctPrimitive(instance, type)
        : instance == null || type.isAssignableFrom(instance.getClass());
  }

  private static boolean correctPrimitive(Object argument, Class<?> type) {
    try {
      Method method = Overloading.class.getDeclaredMethod("method", type);
      method.setAccessible(true);
      method.invoke(null, argument);
      return true;
    } catch (IllegalArgumentException e) {
      return false;
    } catch (NoSuchMethodException e) {
      throw new Error(e);
    } catch (IllegalAccessException e) {
      throw new Error(e);
    } catch (InvocationTargetException e) {
      throw new Error(e);
    }
  }

  @SuppressWarnings("unused")
  private static class Overloading {
    private static void method(byte argument) {}

    private static void method(short argument) {}

    private static void method(int argument) {}

    private static void method(long argument) {}

    private static void method(float argument) {}

    private static void method(double argument) {}

    private static void method(boolean argument) {}

    private static void method(char argument) {}
  }
}

Answer 2

是的，您可以使用Reflection API中的getDeclaredMethod来验证是否声明了具有给定签名的特定方法。可以在文档中找到一个示例（在底部）：http://docs.oracle.com/javase/tutorial/reflect/member/methodInvocation.html

这可能会有效，但我没有测试它：

public boolean hasMethod( Class<?> clazz, String methodName, Class[] argTypes ) {
    try {
        clazz.getDeclaredMethod( methodName, argTypes );
        return true;
    } catch( NoSuchMethodException e ) {
        return false;
    } catch( Exception e ) {
        // something else went wrong
        // you definitely wanna handle this case more gracefully
        throw new IllegalStateException( "Uh-Oh!", e );
    }
}

// example call for a method named someMethod that takes an array of strings
// as its only argument
Class[] argTypes = new Class[] { String[].class };
boolean hasMethod = hasMethod( yourClass, "someMethod", argTypes );

Answer 3

你在问什么

在运行时，首先创建方法，实例和参数列表并且只在一段时间之后在代码的不同位置调用它。一世希望尽早发现问题，而不是浪费时间和报告非信息堆栈跟踪的异常。

是不可能的。对于一些

IllegalArgumentException - 如果方法是实例方法而且指定的对象参数不是类或接口的实例声明底层方法（或子类或实现者）物）;如果实际参数和形式参数的数量不同;如果原始参数的解包转换失败;或者，如果，之后可能展开，参数值无法转换为通过方法调用转换对应的形式参数类型。

你可以自己检查一下。例如，您可以在实例上执行instanceof，或者在其上使用Class#isInstance()。您可以比较您拥有的参数数量和方法所需的参数数量。对于原语的类型转换，它有点难以测试，可能取决于实际知道哪些类型被转换。

当您需要并处理invoke时，最好的选择是IllegalArgumentException。

如何干运行Method.invoke（）

3 个答案: