特殊的异常InvocationTargetException

InvocationTargetException是什么

JavaDoc一上来就说了：

InvocationTargetException is a checked exception that wraps an exception thrown by an invoked method or constructor.
InvocationTargetException是一个受检查异常，当被调用的方法或构造器内部抛出异常，该异常将会被包装成InvocationTargetException来进行接收

以下是知乎作者RednaxelaFX对其的描述

链接：https://www.zhihu.com/question/56718746/answer/150173531
InvocationTargetException 存在的意义是什么？
因为“原来的异常”无法直接以一种统一而又明确的方式表达出来，所以使用InvocationTargetException来将原来的异常包装起来，通过多加一层间接层的方式来提供统一的访问途径。
Java方法可以静态声明它可能会抛出一组固定的异常类型。而反射API里，Method.invoke() 与 Constructor.newInstance() 这些方法有“双重身份”——它们既代表要调用指定的目标方法，自身也是一个方法；目标方法可能会抛出异常，而它们自身在调用目标方法前也可能会抛出一些异常（例如IllegalArgumentException）。它们要调用的目标方法可能抛出任意Throwable类的派生类的异常，但它们自身却不能根据要调用的目标而“动态”改变自己声明要抛出的异常类型，而只能静态声明一组可能抛出的异常类型。声明抛出Throwable或Exception的话，这就太宽泛，难以准确反映异常的原因和意图；但不声明成这么宽泛的异常类型的话又无法完整覆盖所有可能由目标方法抛出的异常。那怎么办？简单，新增一个check exception类型，InvocationTargetException，将原本由目标方法抛出的异常包装起来，这样就可以给Method.invoke() / Constructor.newInstance() 的调用者一个统一的接口，既明确了“这个异常是由目标方法抛出的，不是由我自己抛出的”的意图，又能完整覆盖目标方法所能抛出的所有异常类型（InvocationTargetException.getTargetException() / getCause() 的类型是Throwable）。

大白话：在反射API里，Method.invoke() 与 Constructor.newInstance() 这些方法本身执行时会出现异常，同时被执行的方法或构造器内部也会出现异常，所以InvocationTargetException将被执行的方法或构造器内部抛出的异常进行包装，可通过InvocationTargetException.getTargetException() / getCause()进行获取，但不能直接使用InvocationTargetException，此时如果直接获取InvocationTargetException.getMessage()将会出现Null

直接获取被执行的方法或构造器内部抛出的异常的两种方式

• JDK反射，将会将异常信息封装到InvocationTargetException，可通过InvocationTargetException.getTargetException() / getCause()进行获取
• ASM反射，可直接通过Exception获取

Demo验证

• 引入ASM相关依赖

<dependency>
    <groupId>com.esotericsoftware</groupId>
	<artifactId>reflectasm</artifactId>
	<!-- 版本自行修改 -->
	<version>1.11.7</version>
</dependency>

该依赖包底层使用的是如下依赖

<dependency>
	<groupId>org.ow2.asm</groupId>
	<artifactId>asm</artifactId>
	<version>5.1</version>
</dependency>

• 测试用例如下：

import com.esotericsoftware.reflectasm.MethodAccess;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Objects;

public class AA {
    public static void main(String[] args) {

        Demo demo = new Demo();
        try {
            Method method = findMethod(Demo.class, "haha", new Object[]{"niuwa"});
            method.setAccessible(true);
            method.invoke(demo, 0);
        } catch (InvocationTargetException e) {
            // 如果直接使用InvocationTargetException来接收，则可以使用e.getTargetException() 来进行获取
            System.out.println("---------- JDK Invoke Exception ----------");
            // JDK 反射调用，将调用方法抛出的异常放置在Cause中了，Exception为空
            System.out.println("Cause message by JDK reflection:" + e.getTargetException().getMessage());
            System.out.println("Exception message by JDK reflection:" + e.getMessage());
        } catch (Exception e) {
            // 如果直接使用Exception来接收，则可以使用e.getCause() 来进行获取
            System.out.println("---------- JDK Invoke Exception ----------");
            // JDK 反射调用，将调用方法抛出的异常放置在Cause中了，Exception为空
            System.out.println("Cause message by JDK reflection:" + e.getCause().getMessage());
            System.out.println("Exception message by JDK reflection:" + e.getMessage());
        }

        try {
            MethodAccess access = MethodAccess.get(Demo.class);
            int setNameIndex = access.getIndex("haha");
            access.invoke(demo, setNameIndex, 0);
        } catch (Exception e) {
            System.out.println("---------- ASM Invoke Exception ----------");
            // JDK 反射调用，将调用方法抛出的异常直接放置在Exception中了，Cause为空
            System.out.println("Cause message by ASM reflection:" + e.getCause());
            System.out.println("Exception message by ASM reflection:" + e.getMessage());
        }
    }

    private static Method findMethod(Class<? extends Object> clazz, String methodName, Object[] args) {
        Method[] var6;
        int var5 = (var6 = clazz.getDeclaredMethods()).length;

        for (int var4 = 0; var4 < var5; ++var4) {
            Method method = var6[var4];
            if (method.getName().equals(methodName) && Objects.equals(method.getParameterTypes().length, args.length)) {
                return method;
            }
        }

        Class<?> superClass = clazz.getSuperclass();
        if (superClass != null) {
            return findMethod(superClass, methodName, args);
        } else {
            return null;
        }
    }
}

class Demo {
    public Demo() {

    }

    public void haha(int param) {
        System.err.println("计算结果：" + 10 / param);
    }
}