什么是反射？反射有什么用处？
1. 什么是反射？
“反射（Reflection）能够让运行于JVM中的程序检测和修改运行时的行为。”这个概念常常会和内省（Introspection）混淆，以下是这两个术语在Wikipedia中的解释：
- 内省用于在运行时检测某个对象的类型和其包含的属性；
- 反射用于在运行时检测和修改某个对象的结构及其行为。
从它们的定义可以看出，内省是反射的一个子集。有些语言支持内省，但并不支持反射，如C++。
内省示例：instanceof 运算符用于检测某个对象是否属于特定的类。
| 1 2 3 4 | if (obj instanceof Dog) { Dog d = (Dog) obj; d.bark(); } |
反射示例：Class.forName()方法可以通过类或接口的名称（一个字符串或完全限定名）来获取对应的Class对象。forName方法会触发类的初始化。
| 1 2 3 4 5 | // 使用反射 Class<?> c = Class.forName( "classpath.and.classname" ); Object dog = c.newInstance(); Method m = c.getDeclaredMethod( "bark" , new Class<?>[ 0 ]); m.invoke(dog); |
在Java中，反射更接近于内省，因为你无法改变一个对象的结构。虽然一些API可以用来修改方法和属性的可见性，但并不能修改结构。
2. 我们为何需要反射？
反射能够让我们：
- 在运行时检测对象的类型；
- 动态构造某个类的对象；
- 检测类的属性和方法；
- 任意调用对象的方法；
- 修改构造函数、方法、属性的可见性；
- 以及其他。
反射是框架中常用的方法。
例如，通过反射来遍历包含 @Test 注解的方法，并在运行单元测试时调用它们。（中包含了一些JUnit的使用案例）
对于Web框架，开发人员在配置文件中定义他们对各种接口和类的实现。通过反射机制，框架能够快速地动态初始化所需要的类。
例如，Spring框架使用如下的配置文件：
| 1 2 3 | < bean id = "someID" class = "com.programcreek.Foo" > < property name = "someField" value = "someValue" /> </ bean > |
当Spring容器处理<bean>元素时，会使用Class.forName("com.programcreek.Foo")来初始化这个类，并再次使用反射获取<property>元素对应的setter方法，为对象的属性赋值。
Servlet也会使用相同的机制：
| 1 2 3 4 | < servlet > < servlet-name >someServlet</ servlet-name > < servlet-class >com.programcreek.WhyReflectionServlet</ servlet-class > < servlet > |
3. 如何使用反射？
让我们通过几个典型的案例来学习如何使用反射。
示例1：获取对象的类型名称。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | package myreflection; import java.lang.reflect.Method; public class ReflectionHelloWorld { public static void main(String[] args){ Foo f = new Foo(); System.out.println(f.getClass().getName()); } } class Foo { public void print() { System.out.println( "abc" ); } } |
输出：
| 1 | myreflection.Foo |
示例2：调用未知对象的方法。
在下列代码中，设想对象的类型是未知的。通过反射，我们可以判断它是否包含print方法，并调用它。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | package myreflection; import java.lang.reflect.Method; public class ReflectionHelloWorld { public static void main(String[] args){ Foo f = new Foo(); Method method; try { method = f.getClass().getMethod( "print" , new Class<?>[ 0 ]); method.invoke(f); } catch (Exception e) { e.printStackTrace(); } } } class Foo { public void print() { System.out.println( "abc" ); } } |
输出：
| 1 | abc |
示例3：创建对象
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | package myreflection; public class ReflectionHelloWorld { public static void main(String[] args){ // 创建Class实例 Class<?> c = null ; try { c=Class.forName( "myreflection.Foo" ); } catch (Exception e){ e.printStackTrace(); } // 创建Foo实例 Foo f = null ; try { f = (Foo) c.newInstance(); } catch (Exception e) { e.printStackTrace(); } f.print(); } } class Foo { public void print() { System.out.println( "abc" ); } } |
示例4：获取构造函数，并创建对象。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 | package myreflection; import java.lang.reflect.Constructor; public class ReflectionHelloWorld { public static void main(String[] args){ // 创建Class实例 Class<?> c = null ; try { c=Class.forName( "myreflection.Foo" ); } catch (Exception e){ e.printStackTrace(); } // 创建Foo实例 Foo f1 = null ; Foo f2 = null ; // 获取所有的构造函数 Constructor<?> cons[] = c.getConstructors(); try { f1 = (Foo) cons[ 0 ].newInstance(); f2 = (Foo) cons[ 1 ].newInstance( "abc" ); } catch (Exception e) { e.printStackTrace(); } f1.print(); f2.print(); } } class Foo { String s; public Foo(){} public Foo(String s){ this .s=s; } public void print() { System.out.println(s); } } |
输出：
| 1 2 | null abc |
此外，你可以通过Class实例来获取该类实现的接口、父类、声明的属性等。
示例5：通过反射来修改数组的大小。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | package myreflection; import java.lang.reflect.Array; public class ReflectionHelloWorld { public static void main(String[] args) { int [] intArray = { 1 , 2 , 3 , 4 , 5 }; int [] newIntArray = ( int []) changeArraySize(intArray, 10 ); print(newIntArray); String[] atr = { "a" , "b" , "c" , "d" , "e" }; String[] str1 = (String[]) changeArraySize(atr, 10 ); print(str1); } // 修改数组的大小 public static Object changeArraySize(Object obj, int len) { Class<?> arr = obj.getClass().getComponentType(); Object newArray = Array.newInstance(arr, len); // 复制数组 int co = Array.getLength(obj); System.arraycopy(obj, 0 , newArray, 0 , co); return newArray; } // 打印 public static void print(Object obj) { Class<?> c = obj.getClass(); if (!c.isArray()) { return ; } System.out.println( "\nArray length: " + Array.getLength(obj)); for ( int i = 0 ; i < Array.getLength(obj); i++) { System.out.print(Array.get(obj, i) + " " ); } } } |
输出：
| 1 2 3 4 | Array length: 10 1 2 3 4 5 0 0 0 0 0 Array length: 10 a b c d e null null null null null |
总结
上述示例代码仅仅展现了Java反射机制很小一部分的功能。如果你觉得意犹未尽，可以前去阅读。
参考资料：
原文链接： 翻译： -
译文链接：