InvocationTargetException和UndeclaredThrowableException异常介绍

invocationtargetexception,undeclaredthrowableexception,异常,介绍 · 浏览次数 : 19

小编点评

今天介绍了两个陌生又熟悉的异常类,熟悉是因为我们经常会遇到它们,陌生是好像又从来不知道它们是做什么的假定读者已经清楚了Java的异常分类:一是程序不能处理的错误(Error),二是程序应该避免而可以不去捕获的运行时异常(RuntimeException),三是必须捕获的非运行时异常,也叫受检异常或必检异常InvocationTargetException反射操作过程中,调用目标类的方法可能抛出异常,可以使用Throwable接受,但是太宽泛了,于是我们来个妙招,就是将InvocationTargetException和UndeclaredThrowableException异常的包装,从而找到真正的异常。 **InvocationTargetException**异常是使用反射机制调用的方法时,如果反射参数不是正确的类型,或方法参数的类型与反射参数的类型不匹配,就会抛出InvocationTargetException异常。 **UndeclaredThrowableException**异常是在使用反射机制调用的方法时,如果反射参数是无法找到的,就会抛出UndeclaredThrowableException异常。 **ExceptionUtil**工具类提供了一套方法,可以帮助我们从包装异常类中找到原始的异常,这些方法可以帮助我们更准确地处理异常,以及简化异常的处理流程。 * `unwrapThrowable()`方法可以从包装异常类中提取真正的异常。 * 我们可以使用`unwrapThrowable()`方法来处理InvocationTargetException和UndeclaredThrowableException异常。 * `unwrapThrowable()`方法通过创建一个异常链来跟踪异常的传播,从而帮助我们快速定位异常的根源。

正文

今天来介绍了两个陌生又熟悉的异常类,熟悉是因为我们经常会遇到它们,陌生是好像又从来不知道它们是做什么的

假定读者已经清楚了Java的异常分类:

  1. 一是程序不能处理的错误(Error),
  2. 二是程序应该避免而可以不去捕获的运行时异常(RuntimeException),
  3. 三是必须捕获的非运行时异常,也叫受检异常或必检异常

InvocationTargetException

反射操作过程中,调用目标类的方法可能抛出异常,可以使用Throwable接受,但是太宽泛了

InvocationTargetException就是为解决这个问题而设计的,当反射操作的目标方法中出现异常时,都统一包装成一个必检异常 InvocationTargetException

InvocationTargetException的target属性保存了原始的异常

package exception;

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

public class ExceptionTest{

	public static void makeInvocationTargetException() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException{

		Class<ExceptionTest> exceptionTestClass = ExceptionTest.class;
		Method throwExceptionMethod = exceptionTestClass.getMethod( "throwExceptionMethod" );
		throwExceptionMethod.invoke( new ExceptionTest() );
	}

	public void throwExceptionMethod(){

		int i = 1 / 0;
	}

	public static void main( String[] args ) throws Exception{

		makeInvocationTargetException();
	}
}

输出以下异常,可以看出首先是打印的是InvocationTargetException,后续接着打印了真正异常发生的位置

Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at exception.ExceptionTest.makeInvocationTargetException(ExceptionTest.java:12)
	at exception.ExceptionTest.main(ExceptionTest.java:22)
Caused by: java.lang.ArithmeticException: / by zero
	at exception.ExceptionTest.throwExceptionMethod(ExceptionTest.java:17)
	... 6 more

UndeclaredThrowableException

如果子类中要重写父类中的方法,那么子类方法中抛出的必检异常必须是父类方法中声明过的类型。

代理类一般有两种实现方式:实现目标类相同的接口或者继续目标类

  • 如果代理类和被代理类实现了共同的接口,那代理类方法抛出的受检异常必须是共同接口中声明过的
  • 如果代理类是被代理类的子类,则代理类方法报错的受检异常必须是被代理类的方法中声明过的

可以代理类难免会抛出一些接口或者父类没有声明的受检异常,这时候不抛出,它是受检异常,必须抛出;抛出,没有声明

所以可以把这些受检异常包装为免检异常UndeclaredThrowableException抛出

package exception;

import java.io.IOException;

public interface IPerson{

	void sayHello() throws IOException;
}

package exception;

public class Person implements IPerson{

	@Override
	public void sayHello(){

		System.out.println( "Hello" );
	}
}

package exception;

import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Paths;

public class PersonRecord implements InvocationHandler{

	Object object;

	public PersonRecord( Object object ){

		this.object = object;
	}


	@Override
	public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable{

		System.out.println( "record start" );
		Object rs = method.invoke( object, args );
		System.out.println( "record end" );
		throw new Exception();
	}
}

package exception;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class UndeclaredExceptionTest{

	public static void makeUndeclaredThrowableException() throws IOException{

		IPerson o = (IPerson)Proxy.newProxyInstance( UndeclaredExceptionTest.class.getClassLoader(), new Class[]{ IPerson.class },
				new PersonRecord(new Person()) );
		o.sayHello();
	}



	public static void main( String[] args ) throws Exception{

		makeUndeclaredThrowableException();
	}
}

会有以下输出

record start
Hello
record end
Exception in thread "main" java.lang.reflect.UndeclaredThrowableException
	at com.sun.proxy.$Proxy0.sayHello(Unknown Source)
	at exception.UndeclaredExceptionTest.makeUndeclaredThrowableException(UndeclaredExceptionTest.java:14)
	at exception.UndeclaredExceptionTest.main(UndeclaredExceptionTest.java:21)
Caused by: java.lang.Exception
	at exception.PersonRecord.invoke(PersonRecord.java:25)
	... 3 more

同时发生

这两个异常可以同时发现,也就是在代理类中使用了反射操作,然后异常被包装为InvocationTargetException,而InvocationTargetException没有被接口或者父类声明过,于是又被保证为UndeclaredThrowableException

我们将Person的sayHello方法改一下:

package exception;

public class Person implements IPerson{

	@Override
	public void sayHello(){

		System.out.println( "Hello" );
		int i = 1/0;
	}
}

这样就会同时触发这两种异常

record start
Hello
Exception in thread "main" java.lang.reflect.UndeclaredThrowableException
	at com.sun.proxy.$Proxy0.sayHello(Unknown Source)
	at exception.UndeclaredExceptionTest.makeUndeclaredThrowableException(UndeclaredExceptionTest.java:14)
	at exception.UndeclaredExceptionTest.main(UndeclaredExceptionTest.java:21)
Caused by: java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at exception.PersonRecord.invoke(PersonRecord.java:23)
	... 3 more
Caused by: java.lang.ArithmeticException: / by zero
	at exception.Person.sayHello(Person.java:9)
	... 8 more

总结

  1. InvocationTargetException是在使用反射中发生的异常,包裹了原始的异常
  2. UndeclaredThrowableException是在代理中发生的异常,包裹了原始的异常

在工作的过程中,会经常的遇到这两个异常,以前只是选择性的把它忽略了,在我们了解了他们的组成和原理之后可以更好的找到原始异常

下面是一个Mybatis的工具类,目的是从包装异常类中找到原始的异常:

/**
 *    Copyright 2009-2015 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.reflection;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.UndeclaredThrowableException;

/**
 * @author Clinton Begin
 */
public class ExceptionUtil {

  private ExceptionUtil() {
    // Prevent Instantiation
  }

  /**
   * 拆解InvocationTargetException和UndeclaredThrowableException异常的包装,从而得到被包装的真正异常
   * @param wrapped 包装后的异常
   * @return 拆解出的被包装异常
   */
  public static Throwable unwrapThrowable(Throwable wrapped) {
    // 该变量用以存放拆包得到的异常
    Throwable unwrapped = wrapped;
    while (true) {
      if (unwrapped instanceof InvocationTargetException) {
        // 拆包获得内部异常
        unwrapped = ((InvocationTargetException) unwrapped).getTargetException();
      } else if (unwrapped instanceof UndeclaredThrowableException) {
        // 拆包获得内部异常
        unwrapped = ((UndeclaredThrowableException) unwrapped).getUndeclaredThrowable();
      } else {
        // 该异常无需拆包
        return unwrapped;
      }
    }
  }

}

与InvocationTargetException和UndeclaredThrowableException异常介绍相似的内容: