java.lang.reflect（javalangreflectinvocation null）

发布时间：2022-11-16

本文目录一览：

  1. java.lang中的Class类，与java.lang.reflect包中的construct、method等有什么联系和区别？
  2. java.lang.reflect.InvocationTargetException这个异常什么意思
  3. Java中的Class类与java.lang.reflect间的关系
  4. 为什么会产生java.lang.reflect.invocationtargetexception
  5. java.lang.reflect.invocationtargetexception和数据库表空间有没有关系
  6. java反射机制出错java.lang.reflect.InvocationTargetException

java.lang中的Class类，与java.lang.reflect包中的construct、method等有什么联系和区别？

有一些联系，谈不上区别。他们是独立的类，各自有自己的功能。 你每定义一个类（产生一个java文件） 系统运行的时候，加载java文件 系统就多了一个类的定义 系统里面保存类的定义的方式是就是用java.lang.Class 也就是说 任何类都有一个对应的Class对象， Class clz = String.class ; class静态字段就是该类的Class对象。 通过Class对象，可以得到construct，method这些具体的类定义的细节。 类的细节就是构造函数，普通函数，静态函数，字段成员等等，就对应了java.lang.reflect下面的那一堆。

java.lang.reflect.InvocationTargetException这个异常什么意思

InvocationTargetException异常由Method.invoke(obj, args...)方法抛出。当被调用的方法的内部抛出了异常而没有被捕获时，将由此异常接收。 至于具体原因，就要看代码和详细的错误信息了。

Java中的Class类与java.lang.reflect间的关系

Class类是java.lang包下的类，针对你的提问, 举一个简单易懂的例子来理解一下:

package com.test;
public class Student {
    //声明私用属性
    private int id;
    private String username;
    private String userpwd;
    private int age;
    //共有属性
    public String str = "some strings";
    //私用方法
    private Student getStudent(){
        return new Student();
    }
    //共有的setter和getter方法
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getUserpwd() {
        return userpwd;
    }
    public void setUserpwd(String userpwd) {
        this.userpwd = userpwd;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }
}

package com.test;
import java.lang.reflect.Method;
public class ClassTest {
    public static void main(String[] args) {
        //获取class对象的方式一
        Student stu = new Student();
        Class class1 = stu.getClass();
        /*
         * 返回一个包含某些 Method 对象的数组，
         * 这些对象反映此 Class 对象所表示的类或接口（
         * 包括那些由该类或接口声明的以及
         * 从超类和超接口继承的那些的类或接口）的公共 member 方法。
         */
        Method[] method = class1.getMethods(); //method[]数组存放的是Method对象
        int length = method.length;
        for(int i=0; i<length; i++){
            System.out.println(method[i].getName()); //method[i]就是一个Method对象
        }
        /*
         * 你要明白class1对象的来源是Student,那么返回的构造函数,方法,属性等信息就和这个类有关
         * 其他构造函数,属性的反射就举例子了, 道理是一样的.
         */
        //获取class对象的方式二
        Class class2 = Student.class;
        //获取class对象的方式三
        Class class3 = Integer.TYPE;
    }
}

为什么会产生java.lang.reflect.invocationtargetexception

InvocationTargetException 是一种包装由调用方法或构造方法所抛出异常的受查异常。这个异常并不是Eclipse插件开发特有的，而是标准JDK中的，它定义在 java.lang.reflect包下。在进行Java开发的时候很少会接触到这个异常，不过在进行Eclipse插件开发中则不同，很多API都声明抛出此类异常，因此必须对此异常进行处理。 例如，我们开发一个方法用来统一处理异常：

private static void handleException(Exception e) {
    MessageDialog.openError(Activator.getDefault().getWorkbench()
        .getDisplay().getActiveShell(), "error", e.getMessage());
    e.printStackTrace();
}

我们发现当传递来的参数e为InvocationTargetException 的时候弹出的对话框中的消息是空的，查看InvocationTargetException 的源码得知InvocationTargetException 并没有覆盖getMessage方法，所以消息当然是空的了。我们需要调用InvocationTargetException 的getTargetException方法得到要被包装的异常，这个异常才是真正我们需要的异常。修改代码如下所示：

private static void handleException(Exception e) {
    String msg = null;
    if (e instanceof InvocationTargetException) {
        Throwable targetEx = ((InvocationTargetException) e).getTargetException();
        if (targetEx != null) {
            msg = targetEx.getMessage();
        }
    } else {
        msg = e.getMessage();
    }
    MessageDialog.openError(Activator.getDefault().getWorkbench()
        .getDisplay().getActiveShell(), "error", msg);
    e.printStackTrace();
}

java.lang.reflect.invocationtargetexception和数据库表空间有没有关系

和数据库表空间没有关系。 InvocationTargetException异常由Method.invoke(obj, args...)方法抛出。当被调用的方法的内部抛出了异常而没有被捕获时，将由此异常接收。

示例：

package com.zzj.test.reflect;
public class Reflect {
    public void run(int i) throws ZeroException {
        B b = new B();
        b.run(i);
    }
}
class B {
    public void run(int i) throws ZeroException {
        if (i < 0) {
            throw new ZeroException("参数不能小于零！");
        }
        System.out.println("参数：" + i);
    }
}
class ZeroException extends Exception {
    private static final long serialVersionUID = 1L;
    private String detailMessage;
    public ZeroException(String detailMessage) {
        this.detailMessage = detailMessage;
    }
    public String getMessage() {
        return detailMessage;
    }
}

测试：

package com.zzj.test.reflect;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.zzj.test.reflect.Reflect");
            Method method = clazz.getMethod("run", int.class);
            method.invoke(clazz.newInstance(), -1);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            System.out.println("此处接收被调用方法内部未被捕获的异常");
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

输出：

此处接收被调用方法内部未被捕获的异常
java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at com.zzj.test.reflect.Test.main(Test.java:11)
Caused by: com.zzj.test.reflect.ZeroException: 参数不能小于零！
    at com.zzj.test.reflect.B.run(Reflect.java:13)
    at com.zzj.test.reflect.Reflect.run(Reflect.java:6)
    ... 5 more

也可以直接打印目标异常：

package com.zzj.test.reflect;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.zzj.test.reflect.Reflect");
            Method method = clazz.getMethod("run", int.class);
            method.invoke(clazz.newInstance(), -1);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            System.out.println("此处接收被调用方法内部未被捕获的异常");
            Throwable t = e.getTargetException();// 获取目标异常
            t.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

输出：

此处接收被调用方法内部未被捕获的异常
com.zzj.test.reflect.ZeroException: 参数不能小于零！
    at com.zzj.test.reflect.B.run(Reflect.java:13)
    at com.zzj.test.reflect.Reflect.run(Reflect.java:6)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at com.zzj.test.reflect.Test.main(Test.java:11)

java反射机制出错java.lang.reflect.InvocationTargetException

action.ManagerAction.login(ManagerAction.java:58) 这个地方发生空指针异常了，就是这个地方取值是null了。

推荐文章