关闭

Java语言的动态性支持(二)reflection反射

标签: reflection反射
507人阅读 评论(0) 收藏 举报
分类:
二、Java反射API 

    Java中以反射(reflection)API实现了Java语言的自省,关于自省和反射的区别,笔者无法给出明确的定义。反射API使得Java语言更易实现运行时的动态性,获取Java程序在运行时刻的内部结构,如Java列中的构造方法、域和方法等。反射API的主要功能包括: 
    ① 确定一个对象的类 
    ② 取出类的修饰符(modifiers),字段,方法,构造器和超类 
    ③ 找出某个接口里定义的常量和方法说明 
    ④ 创建一个类实例,这个实例在运行时刻才有名字(运行时间才生成的对象) 
    ⑤ 取得和设定对象数据成员的值,如果数据成员名是运行时刻确定的也能做倒。 
    ⑥ 在运行时刻调用动态对象的方法 
    ⑦ 创建数组,数组大小和类型在运行时刻才确定。也能更改数组成员的值。 


1. 对类的分析 
① 获取对象的类(Class对象) 
Class c = obj.getClass(); 

② 获取一个类的超类 
Class sc = c.getSuperclass(); 
下面一段代码打印一个对象所有的父类 
Java代码  收藏代码
  1. // 分析类的父类  
  2. public static void printSuperclasses(Object o) {  
  3.     Class subclass = o.getClass();  
  4.     Class superclass = subclass.getSuperclass();  
  5.     while (superclass != null) {  
  6.         String className = superclass.getName();  
  7.         System.out.println(className);  
  8.         subclass = superclass;  
  9.         superclass = subclass.getSuperclass();  
  10.     }  
  11. }  


③ 获取类的名字 
String name = c.getName(); 

Java代码  收藏代码
  1. // 分析对象的类  
  2. public static void classAnalysis(Object obj) {  
  3.     // 获得对象的类  
  4.     Class c = obj.getClass();  
  5.     System.out.println(obj + " is instance of class: " + c.getName());  
  6.     // 获得对象所属类的父类  
  7.     Class sc = c.getSuperclass();  
  8.     System.out.println(c.getName() + " inherits from class: "  
  9.             + sc.getName());  
  10. }  


④ 获取类的修饰符 
    int m = c.getModifiers(); 
   此处getModifiers()方法返回的是个整型的结果,结果m并不具体表示哪一种修饰符。先看java.lang.reflect.Modifier类,该类对修饰符进行了相应的包装。 
    类Modifier中定义了一系列的类描述符常量:Modifier.ABSTRACT、Modifier.FINAL、Modifier.PUBLIC等。getModifiers()方法返回的即是类的所有修饰符分别对应的整型值的或运算结果,如public abstract class MyClass{},new MyClass().getClass().getModfiers()即得到Modifier.ABSTRACT | Modifier.PUBLIC。 
    同时Modifier类提供了一些列的方法,用于判断getModifiers()返回的整型数字中包含的类修饰符:Modifier.isPublic(m)、Modifier.isAbstract(m)、Modifier.isFinal(m)等。 
Java代码  收藏代码
  1. // 分析类的修饰符  
  2. public static void printModifiers(Object obj) {  
  3.     System.out.print("Modifier: ");   
  4.     Class c = obj.getClass();  
  5.     int m = c.getModifiers();  
  6.     if (Modifier.isPublic(m))  
  7.         System.out.print("public ");  
  8.     if (Modifier.isAbstract(m))  
  9.         System.out.print("abstract ");  
  10.     if (Modifier.isFinal(m))  
  11.         System.out.print("final ");  
  12.     System.out.println(c.getName());  
  13. }  


⑤ 确定一个类实现的接口 
    Class[] theInterfaces = c.getInterfaces(); 
    从上面的语句中可以看到,接口在反射的API中也是用Class表示的,接口是一种特殊的抽象类。可以使用Class类的isInterface()方法判断一个Class类型是一个类还是接口。 
Java代码  收藏代码
  1. // 分析类的接口  
  2. public static void printInterfaceNames(Object o) {  
  3.     Class c = o.getClass();  
  4.     Class[] theInterfaces = c.getInterfaces();  
  5.     for (int i = 0; i < theInterfaces.length; i++) {  
  6.         String interfaceName = theInterfaces[i].getName();  
  7.         System.out.println(interfaceName);  
  8.     }  
  9. }  

Java代码  收藏代码
  1. // 判断接口  
  2. public static void verifyInterface(Class c) {  
  3.     String name = c.getName();  
  4.     if (c.isInterface()) {  
  5.         System.out.println(name + "  是接口.");  
  6.     } else {  
  7.         System.out.println(name + "  是类.");  
  8.     }  
  9. }  


⑥ 获取类的字段 
    一个类的字段(Field)可能来自本类、父类、实现的接口或者接口的接口,可以使用Class对象的getFields()方法获取类中所有的public属性的字段的数组(Field对象数组)。Field对象提供方法取得字段的名字、类型和描述符,甚至可以给字段赋值或者取字段的值。当然,Class类对象提供了getDeclaredFields()方法获取包括public属性在内的所有在类中声明了的域。 

Java代码  收藏代码
  1. // 分析类的字段  
  2. public static void printFieldNames(Object o) {  
  3.     Class c = o.getClass();  
  4.     //public的字段  
  5.     Field[] publicFields = c.getFields();  
  6.     for (int i = 0; i < publicFields.length; i++) {  
  7.         String fieldName = publicFields[i].getName();  
  8.         Class typeClass = publicFields[i].getType();  
  9.         String fieldType = typeClass.getName();  
  10.         System.out.println("字段名: " + fieldName + ",  类型: " + fieldType);  
  11.     }  
  12.     //所有的字段  
  13.     Field[] allFields = c.getDeclaredFields();  
  14.     for (int i = 0; i < allFields.length; i++) {  
  15.         String fieldName = allFields[i].getName();  
  16.         Class typeClass = allFields[i].getType();  
  17.         String fieldType = typeClass.getName();  
  18.         System.out.println("字段名: " + fieldName + ",  类型: " + fieldType);  
  19.     }  
  20. }  


⑦ 获取构造方法 
    构造方法是在创建类对象时调用的特殊方法,构造方法可以重载,由它们的参数加以区别。调用getConstructors方法可以取得类构造方法的有关信息,这个方法返回一个数组的 
Constructor对象。可以用 Constructor对象里的相关方法来确定构造方法的名字、描述符、参数类型和抛出的意外列表。也可以用Constructor.newInstance创建一个新的Constructor对象。 
Java代码  收藏代码
  1. //分析类的构造方法  
  2. public static void showConstructors(Object o) {  
  3.     Class c = o.getClass();  
  4.     Constructor[] theConstructors = c.getConstructors();  
  5.     for (int i = 0; i < theConstructors.length; i++) {  
  6.         System.out.print(theConstructors[i].getName());  
  7.         System.out.print(" ( ");  
  8.         Class[] parameterTypes = theConstructors[i].getParameterTypes();  
  9.         for (int k = 0; k < parameterTypes.length; k++) {  
  10.             String parameterString = parameterTypes[k].getName();  
  11.             System.out.print(parameterString + " ");  
  12.         }  
  13.         System.out.println(")");  
  14.     }  
  15. }  


⑧ 获取成员方法 
    如何找出类的public方法呢?当然是调用getMethods方法。由getMethods方法返回一个数组,数组元素类型是Method对象。方法的名字,类型,参数,描述和抛出的意外都可 
以由Method对象的方法来取得。用 Method.invoke 方法自己调用这个方法。 
    Method类的对象可以通过getName取方法名、getReturnType取返回值的类型、用 
getParameterTypes取得参数类型(Class对象)的数组,对每个参数用getName取参数的类型名。 
    同样,对于非public的方法,可以使用getDeclaredMethods()方法获取。 
Java代码  收藏代码
  1. //分析类中的成员方法  
  2. public static void showMethods(Object o) {  
  3.     Class c = o.getClass();  
  4.     Method[] theMethods = c.getMethods();  
  5.     for (int i = 0; i < theMethods.length; i++) {  
  6.         String methodString = theMethods[i].getName();  
  7.         System.out.println("Name: " + methodString);  
  8.         String returnString = theMethods[i].getReturnType().getName();  
  9.         System.out.println("   Return Type: " + returnString);  
  10.         Class[] parameterTypes = theMethods[i].getParameterTypes();  
  11.         System.out.print("   Parameter Types:");  
  12.         for (int k = 0; k < parameterTypes.length; k++) {  
  13.             String parameterString = parameterTypes[k].getName();  
  14.             System.out.print(" " + parameterString);  
  15.         }  
  16.         System.out.println();  
  17.     }  
  18. }  


2. 实现程序的动态性 
① 创建对象 
    如果知道一个类型,很容易使用new操作符创建一个类的实例。但是如果在编译时并不知道具体要实例化的是哪个类的对象,如何创建该实例呢? 
    Java中提供Class.forName(String className)从一个字符串(含包的类全名称)加载一个类,再利用newInstance方法创建该类的实例。 
Java代码  收藏代码
  1. //动态创建类对象  
  2. public static Object createObject(String className) {  
  3.     Object object = null;  
  4.     try {  
  5.         Class classDefinition = Class.forName(className);  
  6.         object = classDefinition.newInstance();  
  7.     } catch (InstantiationException e) {  
  8.         System.out.println(e);  
  9.     } catch (IllegalAccessException e) {  
  10.         System.out.println(e);  
  11.     } catch (ClassNotFoundException e) {  
  12.         System.out.println(e);  
  13.     }  
  14.     return object;  
  15. }  

    当然,也可以先获取一个类的Constructor,再调用其newInstance方法创建对象。不同的是,constructor对象的newInstance方法需要传递一个对象数组作为构造方法的参数列表。 
Java代码  收藏代码
  1. //使用Constructor动态创建对象  
  2. public static Object createObject(Constructor constructor, Object[] arguments) {  
  3.     System.out.println("Constructor: " + constructor.toString());  
  4.     Object object = null;  
  5.     try {  
  6.         object = constructor.newInstance(arguments);  
  7.         System.out.println("Object: " + object.toString());  
  8.         return object;  
  9.     } catch (InstantiationException e) {  
  10.         System.out.println(e);  
  11.     } catch (IllegalAccessException e) {  
  12.         System.out.println(e);  
  13.     } catch (IllegalArgumentException e) {  
  14.         System.out.println(e);  
  15.     } catch (InvocationTargetException e) {  
  16.         System.out.println(e);  
  17.     }  
  18.     return object;  
  19. }  


② 获取/设置字段值 
    利用Reflection API获取或者设置字段的值,首先要得到Class对象,然后利用Class对象的getField方法取得相应的字段Field对象,然后调用Field对象对应的getXXX/setXXX方法获取或者设置属性的值。Filed对象提供getInt/setInt、getLong/setLong等方法对基本类型的属性进行值的获取和设置,可以直接使用get/set方法获取复杂类型属性的值(返回一个对象值/传递一个对象值作为参数)。 
    具体操作方法见如下代码片段。当然,若试图获取/设置一个非public的字段值(getField方法也不能获取非pubic的属性对象,可以尝试使用getDeclaredField方法),将产生IllegalAccessException,可以通过setAccessible(true)使非public的字段可见,然后对字段值进行访问。 

Java代码  收藏代码
  1.     // 获取字段值  
  2.     static void getFiledValue(Object o, String filedName) {  
  3.         Class c = o.getClass();  
  4.         Field filed;  
  5.         Object value;  
  6.         try {  
  7.             filed = c.getField(filedName);  
  8. //          filed = c.getDeclaredField(filedName);  
  9. //          filed.setAccessible(true);  //修改字段访问权限  
  10.             value = filed.get(o);   //可使用getInt、getLong等(若知晓字段基本类型)  
  11.             System.out.println(filedName + ": " + value.toString());  
  12.         } catch (NoSuchFieldException e) {  
  13.             System.out.println(e);  
  14.         } catch (SecurityException e) {  
  15.             System.out.println(e);  
  16.         } catch (IllegalAccessException e) {  
  17.             System.out.println(e);  
  18.         }  
  19.     }  


Java代码  收藏代码
  1.     // 修改字段值  
  2.     public static void setFieldValue(Object o, String filedName, Object value) {  
  3.         Field filed;  
  4.         Class c = o.getClass();  
  5.         try {  
  6.             filed = c.getField(filedName);  
  7. //          filed = c.getDeclaredField(filedName);  
  8. //          filed.setAccessible(true);  //修改字段访问权限  
  9.             filed.set(o, value);    //可使用setInt、setLong等(若知晓字段基本类型)  
  10.         } catch (NoSuchFieldException e) {  
  11.             System.out.println(e);  
  12.         } catch (IllegalAccessException e) {  
  13.             System.out.println(e);  
  14.         }  
  15.     }  


③ 调用方法 
    方法调用的过程类似于设置字段值的过程,首先要得到Class对象,然后调用getMethod方法得到方法Method的对象,getMethod方法要求传递两个参数,一个是方法名,第二个是Class[],即方法参数列表中各参数对应的类型的数组。然后执行Method对象的invoke方法,进行方法的调用,invoke方法需要传递两个参数,第一个是方法绑定的对象,第二个是方法的参数列表。如果是static的方法,则第一个参数将自动被忽略(可为null)。 
    同理,对于非public的方法,可以使用getDeclaredMethod方法获取Method对象,并使用setAccessible设置其可见性。 

Java代码  收藏代码
  1.     //动态调用方法  
  2.     public static Object callMethod(Object o, String methodName,  
  3.             Class paramsType[], Object paramsValue[]) {  
  4.         Object result = null;  
  5.         Class c;  
  6.         Method method;  
  7.         try {  
  8.             c = o.getClass();  
  9.             method = c.getMethod(methodName, paramsType);  
  10. //          method = c.getDeclaredMethod(methodName, paramsType);  
  11. //          method.setAccessible(true);  
  12.             result = method.invoke(o, paramsValue);  
  13.         } catch (NoSuchMethodException e) {  
  14.             System.out.println(e);  
  15.         } catch (IllegalAccessException e) {  
  16.             System.out.println(e);  
  17.         } catch (InvocationTargetException e) {  
  18.             System.out.println(e);  
  19.         }  
  20.         return result;  
  21.     }  


3. 其他操作 
① 操作数组 
    反射API中对数组的操作方式不同于一般的java对象,需要通过专门的java.lang.reflect.Array工具类进行实现。Array类提供了创建和操作数组中元素的方法。Array.newInstance方法用来创建新数组,第一个参数为数组中元素的类型,后面的参数为数组各维度的长度(newInstance为变长参数的方法)。 

Java代码  收藏代码
  1. // 反射API操作数组  
  2. public static void useArray() {  
  3.     String[] names = (String[]) Array.newInstance(String.class10);  
  4.     names[0] = "Hello";  
  5.     Array.set(names, 1"World");  
  6.     String str = (String) Array.get(names, 0);  
  7.     int[][][] matrix1 = (int[][][]) Array.newInstance(int.class333);  
  8.     matrix1[0][0][0] = 1;  
  9.     int[][][] matrix2 = (int[][][]) Array.newInstance(int[].class34);  
  10.     matrix2[0][0] = new int[10];  
  11.     matrix2[0][1] = new int[3];  
  12.     matrix2[0][0][1] = 1;  
  13. }  


② 关于权限和异常 
    使用Java反射API的一个重要好处是可以绕过Java语言中默认的访问控制权限。Constructor、Filed和Method都继承自java.lang.reflect.AccessibleObject,其中的setAccessible方法可以用于设置是否绕过默认的权限检查,否则,访问非public的方法或者字段将产生IllegalAccessException异常。 
    而在利用Invoke方法来调用方法是,如果方法本身抛出异常,invoke方法将抛出InvocationTargetException异常,通过getCause方法可以获取实际的异常信息。 
    在Java7中,为所有与反射相关的异常类添加了一个统一的父类java.lang.ReflectiveOperationException,在处理反射相关的异常时可以直接捕获该异常而不用分别捕获各个异常子类。 

关于Java动态性,除了反射机制外,Java7中提供了一种新的动态调用Java程序的方法,即方法句柄MethodHandler,有些类似于C中的函数指针。此部分内容将在后续的文章中进行单独的分析。 

附件中包含了该文章的测试代码。 
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:99444次
    • 积分:1618
    • 等级:
    • 排名:千里之外
    • 原创:49篇
    • 转载:101篇
    • 译文:0篇
    • 评论:9条
    文章分类
    最新评论