invocationtargetexception是什么意思

什么是InvocationTargetException？

InvocationTargetException是Java中的一个异常类，表示某个方法或构造函数的调用发生了异常。当我们使用反射调用一个方法或构造函数时，如果目标方法或构造函数抛出了异常，反射调用也会抛出InvocationTargetException异常。InvocationTargetException异常是一个受检异常，必须在代码中显式地处理。

public class MyTestClass {
    public void myTestMethod() throws IllegalArgumentException {
        throw new IllegalArgumentException("参数有误");
    }
}

public class Main {
    public static void main(String[] args) {
        MyTestClass testClass = new MyTestClass();
        try {
            Method method = MyTestClass.class.getMethod("myTestMethod");
            method.invoke(testClass);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例代码中，我们定义了一个MyTestClass类，其中包含了一个抛出IllegalArgumentException异常的myTestMethod()方法。在main()方法中，我们使用反射获取myTestMethod()方法，并通过invoke()方法调用它。由于myTestMethod()方法会抛出异常，因此invoke()方法也会抛出InvocationTargetException异常。

InvocationTargetException的原因

InvocationTargetException异常有多种可能的原因，下面列举了一些常见的情况:

1.目标方法或构造函数抛出了异常

当我们使用反射调用一个方法或构造函数时，如果目标方法或构造函数抛出了异常，反射调用也会抛出InvocationTargetException异常。例如:

public class MyTestClass {
    public void myTestMethod() throws Exception {
        throw new Exception("抛出异常");
    }
}

public class Main {
    public static void main(String[] args) {
        MyTestClass testClass = new MyTestClass();
        try {
            Method method = MyTestClass.class.getMethod("myTestMethod");
            method.invoke(testClass);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例代码中，myTestMethod()方法抛出了Exception异常，因此invoke()方法抛出了InvocationTargetException异常。

2.目标方法或构造函数是私有的

当我们使用反射调用一个私有的方法或构造函数时，由于权限不足，反射调用也会抛出InvocationTargetException异常。例如:

public class MyTestClass {
    private void myPrivateMethod() throws IllegalArgumentException {
        throw new IllegalArgumentException("参数有误");
    }
}

public class Main {
    public static void main(String[] args) {
        MyTestClass testClass = new MyTestClass();
        try {
            Method method = MyTestClass.class.getDeclaredMethod("myPrivateMethod");
            method.setAccessible(true);
            method.invoke(testClass);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例代码中，myPrivateMethod()方法是私有的，因此我们无法直接使用getMethod()方法获取该方法。我们需要使用getDeclaredMethod()方法获取该方法，并通过method.setAccessible(true)将其设置为可访问的，才能成功调用它。在这个过程中，如果权限不足，调用invoke()方法会抛出InvocationTargetException异常。

3.目标方法或构造函数是static的

当我们使用反射调用一个static的方法或构造函数时，由于不需要通过实例对象进行调用，我们可以将对象参数设置为null，然后调用invoke()方法。如果目标方法或构造函数是static的，但调用时仍然传入了实例对象，反射调用会抛出InvocationTargetException异常。例如:

public class MyTestClass {
    public static void myStaticMethod() throws IllegalArgumentException {
        throw new IllegalArgumentException("参数有误");
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            Method method = MyTestClass.class.getMethod("myStaticMethod");
            method.invoke(null);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例代码中，myStaticMethod()方法是static的，因此我们可以将对象参数设置为null调用该方法。如果我们错误地传递了一个MyTestClass对象，调用invoke()方法会抛出InvocationTargetException异常。

InvocationTargetException的处理方式

当我们使用反射调用一个方法或构造函数时，如果目标方法或构造函数抛出异常，反射调用会抛出InvocationTargetException异常。在这种情况下，我们有以下几种处理方式:

1.捕获InvocationTargetException异常

我们可以在使用反射调用方法或构造函数的代码块中捕获InvocationTargetException异常，并在catch块中处理目标方法或构造函数抛出的异常。例如:

public class MyTestClass {
    public void myTestMethod() throws IllegalArgumentException {
        throw new IllegalArgumentException("参数有误");
    }
}

public class Main {
    public static void main(String[] args) {
        MyTestClass testClass = new MyTestClass();
        try {
            Method method = MyTestClass.class.getMethod("myTestMethod");
            method.invoke(testClass);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
            Throwable targetException = e.getTargetException();
            System.out.println(targetException.getMessage());
        }
    }
}

在上面的示例代码中，我们使用catch块捕获InvocationTargetException异常，并通过e.getTargetException()获取目标方法或构造函数抛出的异常。我们可以在catch块中处理该异常，或者将异常信息打印出来。

2.重新抛出目标异常

如果我们想在捕获InvocationTargetException异常后继续将目标异常向上抛出，我们可以调用e.getTargetException()方法获取目标异常，并使用throw关键字将其重新抛出。例如:

public class MyTestClass {
    public void myTestMethod() throws IllegalArgumentException {
        throw new IllegalArgumentException("参数有误");
    }
}

public class Main {
    public static void main(String[] args) throws Throwable {
        MyTestClass testClass = new MyTestClass();
        try {
            Method method = MyTestClass.class.getMethod("myTestMethod");
            method.invoke(testClass);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
            throw e.getTargetException();
        }
    }
}

在上面的示例代码中，我们使用throw关键字将目标异常重新抛出，使调用invoke()方法的方法也能捕获到目标异常。

3.处理目标异常并抛出新的异常

如果我们想在捕获InvocationTargetException异常后处理目标异常，并将其转换成其他类型的异常抛出，我们可以通过构造新的异常，并将目标异常作为其cause参数传入来实现。例如:

public class MyTestClass {
    public void myTestMethod() throws MyException {
        throw new MyException("自定义异常信息");
    }
}

public class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}

public class Main {
    public static void main(String[] args) throws Throwable {
        MyTestClass testClass = new MyTestClass();
        try {
            Method method = MyTestClass.class.getMethod("myTestMethod");
            method.invoke(testClass);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
            Throwable targetException = e.getTargetException();
            throw new RuntimeException("发生异常", targetException);
        }
    }
}

在上面的示例代码中，我们定义了一个自定义异常类MyException，并在捕获InvocationTargetException异常后，使用new关键字构造一个新的RuntimeException异常，并将目标异常作为其cause参数传入。这样能够将目标异常转换成其他类型的异常，并抛出。