Home » Java Basics » exceptions » java.lang.reflect.invocationtargetexception – How to handle Invocation Target Exception

About Sotirios-Efstathios Maneas

Sotirios-Efstathios (Stathis) Maneas is a PhD student at the Department of Computer Science at the University of Toronto. His main interests include distributed systems, storage systems, file systems, and operating systems.

java.lang.reflect.invocationtargetexception – How to handle Invocation Target Exception

Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java Virtual Machine. The reflection layer wraps any thrown exception as an InvocationTargetException. In this way, it is clear whether the exception was actually caused by a failure in the reflection call, or a failure within the method called.

The InvocationTargetException is a checked exception that wraps an exception thrown by an invoked method or constructor. The thrown exception is provided at construction time and can be accessed via the getTargetException method. That exception is known as the cause and can be accessed via the getCause method.

 
For more information about the reflection in Java, please refer to the page here.

Error case

The following code snippet throws an InvocationTargetException:

ReflectionExample.java:

package main.java;

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

public class ReflectionExample {

    @SuppressWarnings("unused")
    private int testMethod(String str) {
        if(str.length() == 0)
            throw new IllegalArgumentException("The string must contain at least one character!");

        System.out.println("Inside testMethod: argument's value equals to: \"" + str + "\"");

        return 0;
    }

    public static void main(String... args) {
        try {
            // Retrieve an instance of the current class as an Object.
            Class<?> c = Class.forName("main.java.ReflectionExample");
            Object t = c.newInstance();

            Method[] declaredMethods = c.getDeclaredMethods();
            for (Method method : declaredMethods) {
                String methodName = method.getName();

                // Skip the current main method.
                if(methodName.contains("main"))
                    continue;

                System.out.format("Invoking %s()%n", methodName);
                try {
                    // Declare the method as accessible.
                    method.setAccessible(true);

                    /* Invoke the method with a 'null' parameter value, in order
                     * for an exception to be thrown. */
                    Object returnValue = method.invoke(t, "");

                    System.out.format("%s() returned: %d%n", methodName, returnValue);
                }
                catch (InvocationTargetException ex) {
                    System.err.println("An InvocationTargetException was caught!");
                    Throwable cause = ex.getCause();
                    System.out.format("Invocation of %s failed because of: %s%n",
							methodName, cause.getMessage());
                }
            }
        }
        catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex) {
            System.err.println("The following exception was thrown:");
            ex.printStackTrace();
        }
    }
}

The result of the above snippet is:

Invoking testMethod()
An InvocationTargetException was caught!
Invocation of testMethod failed because of: The string must contain at least one character!

If we carefully observe the code, we will understand why the InvocationTargetException was thrown. Initially, we get an instance of the ReflectionExample class. Then, we iterate over its declared methods and we call the method under the name testMethod, passing an empty String as an argument.

However, the testMethod throws an IllegalArgumentException, in case the length of the string equals to zero. That exception is wrapped as an InvocationTargetException and is thrown in our sample application.

If we change the 39th line to:

Object returnValue = method.invoke(t, "Hello from Java Code Geeks!");

the execution continues without any exception being thrown. As a result, we get the following result:

Invoking testMethod()
Inside testMethod: argument's value equals to: "Hello from Java Code Geeks!"
testMethod() returned: 0

How to deal with the exception

First of all, coding an application using reflection is hard. A developer must have a strong grasp of the internal structure of the Java programming language, because the usage of reflection contains drawbacks and dangers, such as performance overhead and exposure of internal fields and methods.

If you decide to use reflection, consider enclosing your code inside a try-catch statement and manipulate the InvocationTargetException accordingly. Notice that the result of the getCause method can be one of the following:

  1. A null value.
  2. An unchecked exception, such as RuntimeException, IllegalArgumentException, NullPointerException, etc.
  3. A checked exception, such as NameNotFoundException, etc.
  4. A java.lang.Error, such as StackOverflowError, OutOfMemoryError, etc.

In your application’s code, make sure that you check for all aforementioned cases, otherwise your code may produce undesired bugs.

 
This was a tutorial about Java’s InvocationTargetException.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

 

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

 

and many more ....

 

Receive Java & Developer job alerts in your Area

 

Subscribe
Notify of
guest

This site uses Akismet to reduce spam. Learn how your comment data is processed.

0 Comments
Inline Feedbacks
View all comments