[关闭]
@Yano 2016-03-31T01:43:19.000000Z 字数 5201 阅读 1349

Java 反射

Java


什么是反射?

反射(Reflection)能够让运行于 JVM 中的程序检测和修改运行时的行为

Class 类

在程序运行期间,Java运行时系统始终为所有的对象维护一个被称为运行时的类型标识。虚拟机利用运行时信息选择相应的方法执行。可以通过专门的Java类访问这些信息,保存这些信息的类被称为Class。

将Class类中的forName和newInstance配合使用,可以根据存储在字符串中的类名创建一个对象

  1. String s = "java.util.Date";
  2. Object m = Class.forName(s).newInstance();

为什么需要反射?

通过反射,我们能够

JUnit

JUnit通过反射来遍历包含 @Test 注解的方法,并在运行单元测试时调用它们。

Web框架

开发人员可以在配置文件中定义对各种接口和类的实现。通过反射机制,框架能够快速地动态初始化所需要的类。

Spring框架使用如下的配置文件:

  1. <bean id="someID" class="com.programcreek.Foo">
  2. <property name="someField" value="someValue" />
  3. </bean>

当Spring容器处理 bean 元素时,会使用Class.forName("com.programcreek.Foo")来初始化这个类,并再次使用反射获取 property 元素对应的setter方法,为对象的属性赋值。

Servlet

  1. <servlet>
  2. <servlet-name>someServlet</servlet-name>
  3. <servlet-class>com.programcreek.WhyReflectionServlet</servlet-class>
  4. <servlet>

如何使用反射?

反射的基本方法

本着不重复造轮子的原则,API 详细参考自 这里,下面只做简单介绍。

在java.lang.reflect包中有三个重要的类:

对于public域(包括超类成员):

对于其它域(包括私有和受保护的成员,不包括超类成员):

下面介绍 Java 反射的使用,其中 Person 类及测试完整代码在本文最后。

加载类

  1. // 加载类的3种方法
  2. Class clazz = Class.forName("com.yano.reflect.Person");
  3. Class clazz1 = new Person().getClass();
  4. Class class2 = Person.class;

获取类的无参构造函数,并实例化类

  1. Class clazz = Class.forName("com.yano.reflect.Person");
  2. Constructor c = clazz.getConstructor(null);
  3. Person p = (Person) c.newInstance(null);

获取类的含参私有构造函数,并实例化类

  1. Class clazz = Class.forName("com.yano.reflect.Person");
  2. Constructor c = clazz
  3. .getDeclaredConstructor(new Class[] { String.class });
  4. // 由于构造函数是 private 的,所以需要屏蔽Java语言的访问检查
  5. c.setAccessible(true);
  6. Person p = (Person) c
  7. .newInstance(new Object[] { "I'm a reflect name!" });

获取并调用类的无参方法

  1. Class clazz = Class.forName("com.yano.reflect.Person");
  2. Constructor c = clazz.getConstructor(null);
  3. Person p = (Person) c.newInstance(null);
  4. Method method = clazz.getMethod("fun", null);
  5. method.invoke(p, null);

获取并调用类的含参方法

  1. Class clazz = Class.forName("com.yano.reflect.Person");
  2. Constructor c = clazz.getConstructor(null);
  3. Person p = (Person) c.newInstance(null);
  4. Method method = clazz.getMethod("fun", new Class[] { String.class });
  5. method.invoke(p, new Object[] { "I'm a reflect method!" });

获取类的字段

  1. Class clazz = Class.forName("com.yano.reflect.Person");
  2. Constructor c = clazz
  3. .getDeclaredConstructor(new Class[] { String.class });
  4. // 由于构造函数是 private 的,所以需要获取控制权限
  5. c.setAccessible(true);
  6. Person p = (Person) c
  7. .newInstance(new Object[] { "I'm a reflect name!" });
  8. Field f = clazz.getField("name");
  9. Object value = f.get(p);
  10. Class type = f.getType();
  11. System.out.println(type);
  12. if (type.equals(String.class)) {
  13. System.out.println((String) value);
  14. }

完整代码

Person 类

  1. package com.yano.reflect;
  2. public class Person {
  3. public String name = "default name";
  4. public int[] array = new int[10];
  5. public Person() {
  6. System.out.println(name);
  7. for (int i = 0; i < array.length; i++) {
  8. array[i] = i;
  9. }
  10. }
  11. private Person(String name) {
  12. this.name = name;
  13. System.out.println(name);
  14. }
  15. public void fun() {
  16. System.out.println("fun");
  17. }
  18. public void fun(String name) {
  19. System.out.println(name);
  20. }
  21. }

test 类

  1. package com.yano.reflect;
  2. import java.lang.reflect.Constructor;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Method;
  5. public class test {
  6. /**
  7. * 反射:加载类的字节码
  8. *
  9. * @throws SecurityException
  10. * @throws NoSuchMethodException
  11. */
  12. public static void main(String[] args) throws Exception {
  13. refGetClass();
  14. // 获取并调用无参构造函数
  15. refGetPublicConstructor();
  16. // 获取并调用私有的含参构造函数
  17. refGetPrivateConstructor();
  18. // 获取并调用无参方法 fun
  19. refGetMethodWithNoArg();
  20. // 获取并调用有参数方法 fun
  21. refGetMethodWithArg();
  22. // 获取类的字段
  23. refGetField();
  24. }
  25. private static void refGetField() throws Exception {
  26. Class clazz = Class.forName("com.yano.reflect.Person");
  27. Constructor c = clazz
  28. .getDeclaredConstructor(new Class[] { String.class });
  29. // 由于构造函数是 private 的,所以需要获取控制权限
  30. c.setAccessible(true);
  31. Person p = (Person) c
  32. .newInstance(new Object[] { "I'm a reflect name!" });
  33. Field f = clazz.getField("name");
  34. Object value = f.get(p);
  35. Class type = f.getType();
  36. System.out.println(type);
  37. if (type.equals(String.class)) {
  38. System.out.println((String) value);
  39. }
  40. System.out.println();
  41. }
  42. private static void refGetMethodWithArg() throws Exception {
  43. Class clazz = Class.forName("com.yano.reflect.Person");
  44. Constructor c = clazz.getConstructor(null);
  45. Person p = (Person) c.newInstance(null);
  46. Method method = clazz.getMethod("fun", new Class[] { String.class });
  47. method.invoke(p, new Object[] { "I'm a reflect method!" });
  48. System.out.println();
  49. }
  50. private static void refGetMethodWithNoArg() throws Exception {
  51. Class clazz = Class.forName("com.yano.reflect.Person");
  52. Constructor c = clazz.getConstructor(null);
  53. Person p = (Person) c.newInstance(null);
  54. Method method = clazz.getMethod("fun", null);
  55. method.invoke(p, null);
  56. System.out.println();
  57. }
  58. private static void refGetPrivateConstructor() throws Exception {
  59. Class clazz = Class.forName("com.yano.reflect.Person");
  60. Constructor c = clazz
  61. .getDeclaredConstructor(new Class[] { String.class });
  62. // 由于构造函数是 private 的,所以需要屏蔽Java语言的访问检查
  63. c.setAccessible(true);
  64. Person p = (Person) c
  65. .newInstance(new Object[] { "I'm a reflect name!" });
  66. System.out.println();
  67. }
  68. private static void refGetPublicConstructor() throws Exception {
  69. Class clazz = Class.forName("com.yano.reflect.Person");
  70. Constructor c = clazz.getConstructor(null);
  71. Person p = (Person) c.newInstance(null);
  72. System.out.println();
  73. }
  74. private static void refGetClass() throws ClassNotFoundException {
  75. // 加载类的3种方法
  76. Class clazz = Class.forName("com.yano.reflect.Person");
  77. Class clazz1 = new Person().getClass();
  78. Class class2 = Person.class;
  79. System.out.println();
  80. }
  81. }

本文参考自:
1. http://www.programcreek.com/2013/09/java-reflection-tutorial/
2. http://www.importnew.com/9078.html
3. 《Java 核心技术 卷 I》第 5 章

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注