JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。Java反射机制在框架设计中极为广泛，需要深入理解。

反射基础

RTIT（Run-Time Type Identification）运行时类型识别。在《Thinking in Java》一书第十四章中有提到，其作用是在运行时识别一个对象的类型和类的信息。主要有两种方式：一种是“传统的”RTIT，它假定我们在编译时已经知道了所有的类型；另一种是“反射”机制，它允许我们在运行时发现和使用类的信息。
反射就是把java类中的各种成分映射成一个个的Java对象
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。

这里我们首先需要理解Class类，以及类的加载机制；然后基于此我们如何通过反射获取Class类以及类中的成员变量、方法、构造方法等。

Class类

Class类，Class类也是一个实实在在的类，存在于JDK的java.lang包中。Class类的实例表示java应用运行时的类(class and enum)或接口(interface and annotation)（每个java类运行时都在JVM里表现为一个Class对象，可通过类名.class、类型.getClass()、Class.forName(“类名”)等方法获取Class对象）。数组同样也被映射为Class对象的一个类，所有具有相同元素类型和维数的数组都共享该Class对象。基本类型boolean，byte，char，short，int，long，float，double和关键字void同样表现为class对象。

  1. public final class Class<T> implements java.io.Serializable,
  2.                               GenericDeclaration,
  3.                               Type,
  4.                               AnnotatedElement {
  5.     private static final int ANNOTATION= 0x00002000;
  6.     private static final int ENUM      = 0x00004000;
  7.     private static final int SYNTHETIC = 0x00001000;
  9.     private static native void registerNatives();
  10.     static {
  11.         registerNatives();
  12.     }
  14.     /*
  15.      * Private constructor. Only the Java Virtual Machine creates Class objects.   //私有构造器，只有JVM才能调用创建Class对象
  16.      * This constructor is not used and prevents the default constructor being
  17.      * generated.
  18.      */
  19.     private Class(ClassLoader loader) {
  20.         // Initialize final field for classLoader.  The initialization value of non-null
  21.         // prevents future JIT optimizations from assuming this final field is null.
  22.         classLoader = loader;
  23.     }

到这我们也就可以得出以下几点信息：

  • Class类也是类的一种，与class关键字是不一样的。
  • 手动编写的类被编译后会产生一个Class对象，其表示的是创建的类的类型信息，而且这个Class对象保存在同名.class的文件中(字节码文件)
  • 每个通过关键字class标识的类，在内存中有且只有一个与之对应的Class对象来描述其类型信息，无论创建多少个实例对象，其依据的都是用一个Class对象。
  • Class类只存私有构造函数，因此对应Class对象只能由JVM创建和加载
  • Class类的对象作用是运行时提供或获得某个对象的类型信息，这点对于反射技术很重要(关于反射稍后分析)。

类加载

类加载机制和类字节码技术可以参考如下两篇文章：

  • JVM基础 - 类字节码详解
    • 源代码通过编译器编译为字节码，再通过类加载子系统进行加载到JVM中运行
  • JVM基础 - Java类加载机制
    • 这篇文章将带你深入理解Java 类加载机制
      其中，这里我们需要回顾的是：

反射的使用

基于此我们如何通过反射获取Class类对象以及类中的成员变量、方法、构造方法等

在Java中，Class类与java.lang.reflect类库一起对反射技术进行了全力的支持。在反射包中，我们常用的类主要有Constructor类表示的是Class对象所表示的类的构造方法，利用它可以在运行时动态创建对象、Field表示Class对象所表示的类的成员变量，通过它可以在运行时动态修改成员变量的属性值(包含private)、Method表示Class对象所表示的类的成员方法，通过它可以动态调用对象的方法(包含private)，下面将对这几个重要类进行分别说明。

Class类对象的获取

在类加载的时候，jvm会创建一个Class对象
Class对象是可以说是反射中最常用的，获取Class对象的方式的主要有三种

  • 根据类名：类名.class
  • 根据对象：对象.getClass()
  • 根据全限定类名：Class.forName(全限定类名)
  1.     @Test
  2.     public void classTest() throws Exception {
  3.         // 获取Class对象的三种方式
  4.         logger.info("根据类名:  \t" + User.class);
  5.         logger.info("根据对象:  \t" + new User().getClass());
  6.         logger.info("根据全限定类名:\t" + Class.forName("com.test.User"));
  7.         // 常用的方法
  8.         logger.info("获取全限定类名:\t" + userClass.getName());
  9.         logger.info("获取类名:\t" + userClass.getSimpleName());
  10.         logger.info("实例化:\t" + userClass.newInstance());
  11.     }
  13.     // ...
  14.     package com.test;
  16.     public class User {
  17.         private String name = "init";
  18.         private int age;
  19.         public User() {}
  20.         public User(String name, int age) {
  21.             super();
  22.             this.name = name;
  23.             this.age = age;
  24.         }
  25.         private String getName() {
  26.             return name;
  27.         }
  28.         private void setName(String name) {
  29.             this.name = name;
  30.         }
  31.         public int getAge() {
  32.             return age;
  33.         }
  34.         public void setAge(int age) {
  35.             this.age = age;
  36.         }
  37.         @Override
  38.         public String toString() {
  39.             return "User [name=" + name + ", age=" + age + "]";
  40.         }
  41.     }

输出结果：

  1. 根据类名:      class com.test.User
  2. 根据对象:      class com.test.User
  3. 根据全限定类名:    class com.test.User
  4. 获取全限定类名:    com.test.User
  5. 获取类名:    User
  6. 实例化:    User [name=init, age=0]
  • 再来看看Class类的方法
    | 方法名 | 说明 |
    | ————————————————— | ——————————— |
    | forName() | (1)获取Class对象的一个引用，但引用的类还没有加载(该类的第一个对象没有生成)就加载了这个类。(2)为了产生Class引用，forName()立即就进行了初始化。 |
    | Object-getClass() | 获取Class对象的一个引用，返回表示该对象的实际类型的Class引用。 |
    | getName() | 取全限定的类名(包括包名)，即类的完整名字。 |
    | getSimpleName() | 获取类名(不包括包名) |
    | getCanonicalName() | 获取全限定的类名(包括包名) |
    | isInterface() | 判断Class对象是否是表示一个接口 |
    | getInterfaces() | 返回Class对象数组，表示Class对象所引用的类所实现的所有接口。 |
    | getSupercalss() | 返回Class对象，表示Class对象所引用的类所继承的直接基类。应用该方法可在运行时发现一个对象完整的继承结构。 |
    | newInstance() | 返回一个Oject对象，是实现“虚拟构造器”的一种途径。使用该方法创建的类，必须带有无参的构造器。 |
    | getFields() | 获得某个类的所有的公共（public）的字段，包括继承自父类的所有公共字段。 类似的还有getMethods和getConstructors。 |
    | getDeclaredFields | 获得某个类的自己声明的字段，即包括public、private和proteced，默认但是不包括父类声明的任何字段。类似的还有getDeclaredMethods和getDeclaredConstructors。 |

简单测试下

  1. package com.cry;
  2. import java.lang.reflect.Field;
  3. interface I1 {
  4. }
  5. interface I2 {
  6. }
  7. class Cell{
  8.     public int mCellPublic;
  9. }
  10. class Animal extends  Cell{
  11.     private int mAnimalPrivate;
  12.     protected int mAnimalProtected;
  13.     int mAnimalDefault;
  14.     public int mAnimalPublic;
  15.     private static int sAnimalPrivate;
  16.     protected static int sAnimalProtected;
  17.     static int sAnimalDefault;
  18.     public static int sAnimalPublic;
  19. }
  20. class Dog extends Animal implements I1, I2 {
  21.     private int mDogPrivate;
  22.     public int mDogPublic;
  23.     protected int mDogProtected;
  24.     private int mDogDefault;
  25.     private static int sDogPrivate;
  26.     protected static int sDogProtected;
  27.     static int sDogDefault;
  28.     public static int sDogPublic;
  29. }
  30. public class Test {
  31.     public static void main(String[] args) throws IllegalAccessException, InstantiationException {
  32.         Class<Dog> dog = Dog.class;
  33.         //类名打印
  34.         System.out.println(dog.getName()); //com.cry.Dog
  35.         System.out.println(dog.getSimpleName()); //Dog
  36.         System.out.println(dog.getCanonicalName());//com.cry.Dog
  37.         //接口
  38.         System.out.println(dog.isInterface()); //false
  39.         for (Class iI : dog.getInterfaces()) {
  40.             System.out.println(iI);
  41.         }
  42.          /*
  43.           interface com.cry.I1
  44.           interface com.cry.I2
  45.          */
  47.         //父类
  48.         System.out.println(dog.getSuperclass());//class com.cry.Animal
  49.         //创建对象
  50.         Dog d = dog.newInstance();
  51.         //字段
  52.         for (Field f : dog.getFields()) {
  53.             System.out.println(f.getName());
  54.         }
  55.         /*
  56.             mDogPublic
  57.             sDogPublic
  58.             mAnimalPublic
  59.             sAnimalPublic
  60.             mCellPublic  //父类的父类的公共字段也打印出来了
  61.          */
  62.         System.out.println("---------");
  63.         for (Field f : dog.getDeclaredFields()) {
  64.             System.out.println(f.getName());
  65.         }
  66.         /** 只有自己类声明的字段
  67.          mDogPrivate
  68.          mDogPublic
  69.          mDogProtected
  70.          mDogDefault
  71.          sDogPrivate
  72.          sDogProtected
  73.          sDogDefault
  74.          sDogPublic
  75.          */
  76.     }
  77. }

getName、getCanonicalName与getSimpleName的区别：

  • getSimpleName：只获取类名
  • getName：类的全限定名，jvm中Class的表示，可以用于动态加载Class对象，例如Class.forName。
  • getCanonicalName：返回更容易理解的表示，主要用于输出（toString）或log打印，大多数情况下和getName一样，但是在内部类、数组等类型的表示形式就不同了。
  1. package com.cry;
  2. public class Test {
  3.     private  class inner{
  4.     }
  5.     public static void main(String[] args) throws ClassNotFoundException {
  6.         //普通类
  7.         System.out.println(Test.class.getSimpleName()); //Test
  8.         System.out.println(Test.class.getName()); //com.cry.Test
  9.         System.out.println(Test.class.getCanonicalName()); //com.cry.Test
  10.         //内部类
  11.         System.out.println(inner.class.getSimpleName()); //inner
  12.         System.out.println(inner.class.getName()); //com.cry.Test$inner
  13.         System.out.println(inner.class.getCanonicalName()); //com.cry.Test.inner
  14.         //数组
  15.         System.out.println(args.getClass().getSimpleName()); //String[]
  16.         System.out.println(args.getClass().getName()); //[Ljava.lang.String;
  17.         System.out.println(args.getClass().getCanonicalName()); //java.lang.String[]
  18.         //我们不能用getCanonicalName去加载类对象，必须用getName
  19.         //Class.forName(inner.class.getCanonicalName()); 报错
  20.         Class.forName(inner.class.getName());
  21.     }
  22. }

Constructor类及其用法

Constructor类存在于反射包(java.lang.reflect)中，反映的是Class对象所表示的类的构造方法。

获取Constructor对象是通过Class类中的方法获取的，Class类与Constructor相关的主要方法如下：

方法返回值 方法名称 方法说明
static Class<?> forName(String className) 返回与带有给定字符串名的类或接口相关联的 Class 对象。
Constructor getConstructor(Class<?>… parameterTypes) 返回指定参数类型、具有public访问权限的构造函数对象
Constructor<?>[] getConstructors() 返回所有具有public访问权限的构造函数的Constructor对象数组
Constructor getDeclaredConstructor(Class<?>… parameterTypes) 返回指定参数类型、所有声明的（包括private）构造函数对象
Constructor<?>[] getDeclaredConstructor() 返回所有声明的（包括private）构造函数对象
T newInstance() 调用无参构造器创建此 Class 对象所表示的类的一个新实例。

下面看一个简单例子来了解Constructor对象的使用：

  1. public class ConstructionTest implements Serializable {
  2.     public static void main(String[] args) throws Exception {
  4.         Class<?> clazz = null;
  6.         //获取Class对象的引用
  7.         clazz = Class.forName("com.example.javabase.User");
  9.         //第一种方法，实例化默认构造方法，User必须无参构造函数,否则将抛异常
  10.         User user = (User) clazz.newInstance();
  11.         user.setAge(20);
  12.         user.setName("Jack");
  13.         System.out.println(user);
  15.         System.out.println("--------------------------------------------");
  17.         //获取带String参数的public构造函数
  18.         Constructor cs1 =clazz.getConstructor(String.class);
  19.         //创建User
  20.         User user1= (User) cs1.newInstance("hiway");
  21.         user1.setAge(22);
  22.         System.out.println("user1:"+user1.toString());
  24.         System.out.println("--------------------------------------------");
  26.         //取得指定带int和String参数构造函数,该方法是私有构造private
  27.         Constructor cs2=clazz.getDeclaredConstructor(int.class,String.class);
  28.         //由于是private必须设置可访问
  29.         cs2.setAccessible(true);
  30.         //创建user对象
  31.         User user2= (User) cs2.newInstance(25,"hiway2");
  32.         System.out.println("user2:"+user2.toString());
  34.         System.out.println("--------------------------------------------");
  36.         //获取所有构造包含private
  37.         Constructor<?> cons[] = clazz.getDeclaredConstructors();
  38.         // 查看每个构造方法需要的参数
  39.         for (int i = 0; i < cons.length; i++) {
  40.             //获取构造函数参数类型
  41.             Class<?> clazzs[] = cons[i].getParameterTypes();
  42.             System.out.println("构造函数["+i+"]:"+cons[i].toString() );
  43.             System.out.print("参数类型["+i+"]:(");
  44.             for (int j = 0; j < clazzs.length; j++) {
  45.                 if (j == clazzs.length - 1)
  46.                     System.out.print(clazzs[j].getName());
  47.                 else
  48.                     System.out.print(clazzs[j].getName() + ",");
  49.             }
  50.             System.out.println(")");
  51.         }
  52.     }
  53. }
  56. class User {
  57.     private int age;
  58.     private String name;
  59.     public User() {
  60.         super();
  61.     }
  62.     public User(String name) {
  63.         super();
  64.         this.name = name;
  65.     }
  67.     /**
  68.      * 私有构造
  69.      * @param age
  70.      * @param name
  71.      */
  72.     private User(int age, String name) {
  73.         super();
  74.         this.age = age;
  75.         this.name = name;
  76.     }
  78.     public int getAge() {
  79.         return age;
  80.     }
  82.     public void setAge(int age) {
  83.         this.age = age;
  84.     }
  86.     public String getName() {
  87.         return name;
  88.     }
  90.     public void setName(String name) {
  91.         this.name = name;
  92.     }
  94.     @Override
  95.     public String toString() {
  96.         return "User{" +
  97.                 "age=" + age +
  98.                 ", name='" + name + '\'' +
  99.                 '}';
  100.     }
  101. }

输出结果

  1. /* output 
  2. User{age=20, name='Jack'}
  3. --------------------------------------------
  4. user1:User{age=22, name='hiway'}
  5. --------------------------------------------
  6. user2:User{age=25, name='hiway2'}
  7. --------------------------------------------
  8. 构造函数[0]:private com.example.javabase.User(int,java.lang.String)
  9. 参数类型[0]:(int,java.lang.String)
  10. 构造函数[1]:public com.example.javabase.User(java.lang.String)
  11. 参数类型[1]:(java.lang.String)
  12. 构造函数[2]:public com.example.javabase.User()
  13. 参数类型[2]:()

关于Constructor类本身一些常用方法如下(仅部分，其他可查API)

方法返回值 方法名称 方法说明
Class getDeclaringClass() 返回 Class 对象，该对象表示声明由此 Constructor 对象表示的构造方法的类,其实就是返回真实类型（不包含参数）
Type[] getGenericParameterTypes() 按照声明顺序返回一组 Type 对象，返回的就是 Constructor对象构造函数的形参类型。
String getName() 以字符串形式返回此构造方法的名称。
Class<?>[] getParameterTypes() 按照声明顺序返回一组 Class 对象，即返回Constructor 对象所表示构造方法的形参类型
T newInstance(Object… initargs) 使用此 Constructor对象表示的构造函数来创建新实例
String toGenericString() 返回描述此 Constructor 的字符串，其中包括类型参数。

代码演示如下：

  1. Constructor cs3 = clazz.getDeclaredConstructor(int.class,String.class);
  2. System.out.println("-----getDeclaringClass-----");
  3. Class uclazz=cs3.getDeclaringClass();
  4. //Constructor对象表示的构造方法的类
  5. System.out.println("构造方法的类:"+uclazz.getName());
  7. System.out.println("-----getGenericParameterTypes-----");
  8. //对象表示此 Constructor 对象所表示的方法的形参类型
  9. Type[] tps=cs3.getGenericParameterTypes();
  10. for (Type tp:tps) {
  11.     System.out.println("参数名称tp:"+tp);
  12. }
  13. System.out.println("-----getParameterTypes-----");
  14. //获取构造函数参数类型
  15. Class<?> clazzs[] = cs3.getParameterTypes();
  16. for (Class claz:clazzs) {
  17.     System.out.println("参数名称:"+claz.getName());
  18. }
  19. System.out.println("-----getName-----");
  20. //以字符串形式返回此构造方法的名称
  21. System.out.println("getName:"+cs3.getName());
  23. System.out.println("-----getoGenericString-----");
  24. //返回描述此 Constructor 的字符串，其中包括类型参数。
  25. System.out.println("getoGenericString():"+cs3.toGenericString());

输出结果

  1. -----getDeclaringClass-----
  2. 构造方法的类:com.example.javabase.User
  3. -----getGenericParameterTypes-----
  4. 参数名称tp:int
  5. 参数名称tp:class java.lang.String
  6. -----getParameterTypes-----
  7. 参数名称:int
  8. 参数名称:java.lang.String
  9. -----getName-----
  10. getName:com.example.javabase.User
  11. -----getoGenericString-----
  12. getoGenericString():private com.example.javabase.User(int,java.lang.String)

Field类及其用法

Field提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。

同样的道理，我们可以通过Class类的提供的方法来获取代表字段信息的Field对象，Class类与Field对象相关方法如下：

方法返回值 方法名称 方法说明
Field getDeclaredField(String name) 获取指定name名称的(包含private修饰的)字段，不包括继承的字段
Field[] getDeclaredField() 获取Class对象所表示的类或接口的所有(包含private修饰的)字段,不包括继承的字段
Field getField(String name) 获取指定name名称、具有public修饰的字段，包含继承字段
Field[] getField() 获取修饰符为public的字段，包含继承字段

下面的代码演示了上述方法的使用过程

  1. public class ReflectField {
  3.     public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
  4.         Class<?> clazz = Class.forName("reflect.Student");
  5.         //获取指定字段名称的Field类,注意字段修饰符必须为public而且存在该字段,
  6.         // 否则抛NoSuchFieldException
  7.         Field field = clazz.getField("age");
  8.         System.out.println("field:"+field);
  10.         //获取所有修饰符为public的字段,包含父类字段,注意修饰符为public才会获取
  11.         Field fields[] = clazz.getFields();
  12.         for (Field f:fields) {
  13.             System.out.println("f:"+f.getDeclaringClass());
  14.         }
  16.         System.out.println("================getDeclaredFields====================");
  17.         //获取当前类所字段(包含private字段),注意不包含父类的字段
  18.         Field fields2[] = clazz.getDeclaredFields();
  19.         for (Field f:fields2) {
  20.             System.out.println("f2:"+f.getDeclaringClass());
  21.         }
  22.         //获取指定字段名称的Field类,可以是任意修饰符的自动,注意不包含父类的字段
  23.         Field field2 = clazz.getDeclaredField("desc");
  24.         System.out.println("field2:"+field2);
  25.     }
  26.     /**
  27.       输出结果: 
  28.      field:public int reflect.Person.age
  29.      f:public java.lang.String reflect.Student.desc
  30.      f:public int reflect.Person.age
  31.      f:public java.lang.String reflect.Person.name
  33.      ================getDeclaredFields====================
  34.      f2:public java.lang.String reflect.Student.desc
  35.      f2:private int reflect.Student.score
  36.      field2:public java.lang.String reflect.Student.desc
  37.      */
  38. }
  40. class Person{
  41.     public int age;
  42.     public String name;
  43.     //省略set和get方法
  44. }
  46. class Student extends Person{
  47.     public String desc;
  48.     private int score;
  49.     //省略set和get方法
  50. }

上述方法需要注意的是，如果我们不期望获取其父类的字段，则需使用Class类的getDeclaredField/getDeclaredFields方法来获取字段即可，倘若需要连带获取到父类的字段，那么请使用Class类的getField/getFields，但是也只能获取到public修饰的的字段，无法获取父类的私有字段。下面将通过Field类本身的方法对指定类属性赋值，代码演示如下：

  1. //获取Class对象引用
  2. Class<?> clazz = Class.forName("reflect.Student");
  4. Student st= (Student) clazz.newInstance();
  5. //获取父类public字段并赋值
  6. Field ageField = clazz.getField("age");
  7. ageField.set(st,18);
  8. Field nameField = clazz.getField("name");
  9. nameField.set(st,"Lily");
  11. //只获取当前类的字段,不获取父类的字段
  12. Field descField = clazz.getDeclaredField("desc");
  13. descField.set(st,"I am student");
  14. Field scoreField = clazz.getDeclaredField("score");
  15. //设置可访问，score是private的
  16. scoreField.setAccessible(true);
  17. scoreField.set(st,88);
  18. System.out.println(st.toString());
  20. //输出结果：Student{age=18, name='Lily ,desc='I am student', score=88} 
  22. //获取字段值
  23. System.out.println(scoreField.get(st));
  24. // 88

其中的set(Object obj, Object value)方法是Field类本身的方法，用于设置字段的值，而get(Object obj)则是获取字段的值，当然关于Field类还有其他常用的方法如下：

方法返回值 方法名称 方法说明
void set(Object obj, Object value) 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
Object get(Object obj) 返回指定对象上此 Field 表示的字段的值
Class<?> getType() 返回一个 Class 对象，它标识了此Field 对象所表示字段的声明类型。
boolean isEnumConstant() 如果此字段表示枚举类型的元素则返回 true；否则返回 false
String toGenericString() 返回一个描述此 Field（包括其一般类型）的字符串
String getName() 返回此 Field 对象表示的字段的名称
Class<?> getDeclaringClass() 返回表示类或接口的 Class 对象，该类或接口声明由此 Field 对象表示的字段
void setAccessible(boolean flag) 将此对象的 accessible 标志设置为指示的布尔值,即设置其可访问性

上述方法可能是较为常用的，事实上在设置值的方法上，Field类还提供了专门针对基本数据类型的方法，如setInt()/getInt()、setBoolean()/getBoolean、setChar()/getChar()等等方法，这里就不全部列出了，需要时查API文档即可。需要特别注意的是被final关键字修饰的Field字段是安全的，在运行时可以接收任何修改，但最终其实际值是不会发生改变的。

Method类及其用法

Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息，所反映的方法可能是类方法或实例方法（包括抽象方法）。

下面是Class类获取Method对象相关的方法：

方法返回值 方法名称 方法说明
Method getDeclaredMethod(String name, Class<?>… parameterTypes) 返回一个指定参数的Method对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
Method[] getDeclaredMethod() 返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
Method getMethod(String name, Class<?>… parameterTypes) 返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
Method[] getMethods() 返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。

同样通过案例演示上述方法：

  1. import java.lang.reflect.Method;
  3. public class ReflectMethod  {
  6.     public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
  8.         Class clazz = Class.forName("reflect.Circle");
  10.         //根据参数获取public的Method,包含继承自父类的方法
  11.         Method method = clazz.getMethod("draw",int.class,String.class);
  13.         System.out.println("method:"+method);
  15.         //获取所有public的方法:
  16.         Method[] methods =clazz.getMethods();
  17.         for (Method m:methods){
  18.             System.out.println("m::"+m);
  19.         }
  21.         System.out.println("=========================================");
  23.         //获取当前类的方法包含private,该方法无法获取继承自父类的method
  24.         Method method1 = clazz.getDeclaredMethod("drawCircle");
  25.         System.out.println("method1::"+method1);
  26.         //获取当前类的所有方法包含private,该方法无法获取继承自父类的method
  27.         Method[] methods1=clazz.getDeclaredMethods();
  28.         for (Method m:methods1){
  29.             System.out.println("m1::"+m);
  30.         }
  31.     }
  32. }
  34. class Shape {
  35.     public void draw(){
  36.         System.out.println("draw");
  37.     }
  39.     public void draw(int count , String name){
  40.         System.out.println("draw "+ name +",count="+count);
  41.     }
  43. }
  44. class Circle extends Shape{
  46.     private void drawCircle(){
  47.         System.out.println("drawCircle");
  48.     }
  49.     public int getAllCount(){
  50.         return 100;
  51.     }
  52. }

输出结果:

  1. method:public void reflect.Shape.draw(int,java.lang.String)
  3. m::public int reflect.Circle.getAllCount()
  4. m::public void reflect.Shape.draw()
  5. m::public void reflect.Shape.draw(int,java.lang.String)
  6. m::public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
  7. m::public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
  8. m::public final void java.lang.Object.wait() throws java.lang.InterruptedException
  9. m::public boolean java.lang.Object.equals(java.lang.Object)
  10. m::public java.lang.String java.lang.Object.toString()
  11. m::public native int java.lang.Object.hashCode()
  12. m::public final native java.lang.Class java.lang.Object.getClass()
  13. m::public final native void java.lang.Object.notify()
  14. m::public final native void java.lang.Object.notifyAll()
  16. =========================================
  17. method1::private void reflect.Circle.drawCircle()
  19. m1::public int reflect.Circle.getAllCount()
  20. m1::private void reflect.Circle.drawCircle()

在通过getMethods方法获取Method对象时，会把父类的方法也获取到，如上的输出结果，把Object类的方法都打印出来了。而getDeclaredMethod/getDeclaredMethods方法都只能获取当前类的方法。我们在使用时根据情况选择即可。下面将演示通过Method对象调用指定类的方法：

  1. Class clazz = Class.forName("reflect.Circle");
  2. //创建对象
  3. Circle circle = (Circle) clazz.newInstance();
  5. //获取指定参数的方法对象Method
  6. Method method = clazz.getMethod("draw",int.class,String.class);
  8. //通过Method对象的invoke(Object obj,Object... args)方法调用
  9. method.invoke(circle,15,"圈圈");
  11. //对私有无参方法的操作
  12. Method method1 = clazz.getDeclaredMethod("drawCircle");
  13. //修改私有方法的访问标识
  14. method1.setAccessible(true);
  15. method1.invoke(circle);
  17. //对有返回值得方法操作
  18. Method method2 =clazz.getDeclaredMethod("getAllCount");
  19. Integer count = (Integer) method2.invoke(circle);
  20. System.out.println("count:"+count);

输出结果

  1. draw 圈圈,count=15
  2. drawCircle
  3. count:100

在上述代码中调用方法，使用了Method类的invoke(Object obj,Object... args)第一个参数代表调用的对象，第二个参数传递的调用方法的参数。这样就完成了类方法的动态调用。

方法返回值 方法名称 方法说明
Object invoke(Object obj, Object… args) 对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
Class<?> getReturnType() 返回一个 Class 对象，该对象描述了此 Method 对象所表示的方法的正式返回类型,即方法的返回类型
Type getGenericReturnType() 返回表示由此 Method 对象所表示方法的正式返回类型的 Type 对象，也是方法的返回类型。
Class<?>[] getParameterTypes() 按照声明顺序返回 Class 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型。即返回方法的参数类型组成的数组
Type[] getGenericParameterTypes() 按照声明顺序返回 Type 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型的，也是返回方法的参数类型
String getName() 以 String 形式返回此 Method 对象表示的方法名称，即返回方法的名称
boolean isVarArgs() 判断方法是否带可变参数，如果将此方法声明为带有可变数量的参数，则返回 true；否则，返回 false。
String toGenericString() 返回描述此 Method 的字符串，包括类型参数。

getReturnType方法/getGenericReturnType方法都是获取Method对象表示的方法的返回类型，只不过前者返回的Class类型后者返回的Type(前面已分析过)，Type就是一个接口而已，在Java8中新增一个默认的方法实现，返回的就参数类型信息

  1. public interface Type {
  2.     //1.8新增
  3.     default String getTypeName() {
  4.         return toString();
  5.     }
  6. }

而getParameterTypes/getGenericParameterTypes也是同样的道理，都是获取Method对象所表示的方法的参数类型，其他方法与前面的Field和Constructor是类似的。

反射机制执行的流程

深入理解java反射原理

先看个例子

  1. public class HelloReflect {
  2.     public static void main(String[] args) {
  3.         try {
  4.             // 1. 使用外部配置的实现，进行动态加载类
  5.             TempFunctionTest test = (TempFunctionTest)Class.forName("com.tester.HelloReflect").newInstance();
  6.             test.sayHello("call directly");
  7.             // 2. 根据配置的函数名，进行方法调用（不需要通用的接口抽象）
  8.             Object t2 = new TempFunctionTest();
  9.             Method method = t2.getClass().getDeclaredMethod("sayHello", String.class);
  10.             method.invoke(test, "method invoke");
  11.         } catch (ClassNotFoundException e) {
  12.             e.printStackTrace();
  13.         } catch (InstantiationException e) {
  14.             e.printStackTrace();
  15.         } catch (IllegalAccessException e) {
  16.             e.printStackTrace();
  17.         } catch (NoSuchMethodException e ) {
  18.             e.printStackTrace();
  19.         } catch (InvocationTargetException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  24.     public void sayHello(String word) {
  25.         System.out.println("hello," + word);
  26.     }
  28. }

反射获取类实例

首先调用了java.lang.Class的静态方法，获取类信息。

  1.     @CallerSensitive
  2.     public static Class<?> forName(String className)
  3.                 throws ClassNotFoundException {
  4.         // 先通过反射，获取调用进来的类信息，从而获取当前的 classLoader
  5.         Class<?> caller = Reflection.getCallerClass();
  6.         // 调用native方法进行获取class信息
  7.         return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
  8.     }

forName()反射获取类信息，并没有将实现留给了java,而是交给了jvm去加载。
主要是先获取ClassLoader, 然后调用native方法，获取信息，加载类则是回调java.lang.ClassLoader。
最后，jvm又会回调ClassLoader进类加载。

  2.     // 
  3.     public Class<?> loadClass(String name) throws ClassNotFoundException {
  4.         return loadClass(name, false);
  5.     }
  7.         // sun.misc.Launcher
  8.         public Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
  9.             int var3 = var1.lastIndexOf(46);
  10.             if(var3 != -1) {
  11.                 SecurityManager var4 = System.getSecurityManager();
  12.                 if(var4 != null) {
  13.                     var4.checkPackageAccess(var1.substring(0, var3));
  14.                 }
  15.             }
  17.             if(this.ucp.knownToNotExist(var1)) {
  18.                 Class var5 = this.findLoadedClass(var1);
  19.                 if(var5 != null) {
  20.                     if(var2) {
  21.                         this.resolveClass(var5);
  22.                     }
  24.                     return var5;
  25.                 } else {
  26.                     throw new ClassNotFoundException(var1);
  27.                 }
  28.             } else {
  29.                 return super.loadClass(var1, var2);
  30.             }
  31.         }
  32.     // java.lang.ClassLoader
  33.     protected Class<?> loadClass(String name, boolean resolve)
  34.         throws ClassNotFoundException
  35.     {
  36.         // 先获取锁
  37.         synchronized (getClassLoadingLock(name)) {
  38.             // First, check if the class has already been loaded
  39.             // 如果已经加载了的话，就不用再加载了
  40.             Class<?> c = findLoadedClass(name);
  41.             if (c == null) {
  42.                 long t0 = System.nanoTime();
  43.                 try {
  44.                     // 双亲委托加载
  45.                     if (parent != null) {
  46.                         c = parent.loadClass(name, false);
  47.                     } else {
  48.                         c = findBootstrapClassOrNull(name);
  49.                     }
  50.                 } catch (ClassNotFoundException e) {
  51.                     // ClassNotFoundException thrown if class not found
  52.                     // from the non-null parent class loader
  53.                 }
  55.                 // 父类没有加载到时，再自己加载
  56.                 if (c == null) {
  57.                     // If still not found, then invoke findClass in order
  58.                     // to find the class.
  59.                     long t1 = System.nanoTime();
  60.                     c = findClass(name);
  62.                     // this is the defining class loader; record the stats
  63.                     sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
  64.                     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
  65.                     sun.misc.PerfCounter.getFindClasses().increment();
  66.                 }
  67.             }
  68.             if (resolve) {
  69.                 resolveClass(c);
  70.             }
  71.             return c;
  72.         }
  73.     }
  75.     protected Object getClassLoadingLock(String className) {
  76.         Object lock = this;
  77.         if (parallelLockMap != null) {
  78.             // 使用 ConcurrentHashMap来保存锁
  79.             Object newLock = new Object();
  80.             lock = parallelLockMap.putIfAbsent(className, newLock);
  81.             if (lock == null) {
  82.                 lock = newLock;
  83.             }
  84.         }
  85.         return lock;
  86.     }
  88.     protected final Class<?> findLoadedClass(String name) {
  89.         if (!checkName(name))
  90.             return null;
  91.         return findLoadedClass0(name);
  92.     }

下面来看一下newInstance()的实现方式。

  1.     // 首先肯定是 Class.newInstance
  2.     @CallerSensitive
  3.     public T newInstance()
  4.         throws InstantiationException, IllegalAccessException
  5.     {
  6.         if (System.getSecurityManager() != null) {
  7.             checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
  8.         }
  10.         // NOTE: the following code may not be strictly correct under
  11.         // the current Java memory model.
  13.         // Constructor lookup
  14.         // newInstance() 其实相当于调用类的无参构造函数，所以，首先要找到其无参构造器
  15.         if (cachedConstructor == null) {
  16.             if (this == Class.class) {
  17.                 // 不允许调用 Class 的 newInstance() 方法
  18.                 throw new IllegalAccessException(
  19.                     "Can not call newInstance() on the Class for java.lang.Class"
  20.                 );
  21.             }
  22.             try {
  23.                 // 获取无参构造器
  24.                 Class<?>[] empty = {};
  25.                 final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
  26.                 // Disable accessibility checks on the constructor
  27.                 // since we have to do the security check here anyway
  28.                 // (the stack depth is wrong for the Constructor's
  29.                 // security check to work)
  30.                 java.security.AccessController.doPrivileged(
  31.                     new java.security.PrivilegedAction<Void>() {
  32.                         public Void run() {
  33.                                 c.setAccessible(true);
  34.                                 return null;
  35.                             }
  36.                         });
  37.                 cachedConstructor = c;
  38.             } catch (NoSuchMethodException e) {
  39.                 throw (InstantiationException)
  40.                     new InstantiationException(getName()).initCause(e);
  41.             }
  42.         }
  43.         Constructor<T> tmpConstructor = cachedConstructor;
  44.         // Security check (same as in java.lang.reflect.Constructor)
  45.         int modifiers = tmpConstructor.getModifiers();
  46.         if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
  47.             Class<?> caller = Reflection.getCallerClass();
  48.             if (newInstanceCallerCache != caller) {
  49.                 Reflection.ensureMemberAccess(caller, this, null, modifiers);
  50.                 newInstanceCallerCache = caller;
  51.             }
  52.         }
  53.         // Run constructor
  54.         try {
  55.             // 调用无参构造器
  56.             return tmpConstructor.newInstance((Object[])null);
  57.         } catch (InvocationTargetException e) {
  58.             Unsafe.getUnsafe().throwException(e.getTargetException());
  59.             // Not reached
  60.             return null;
  61.         }
  62.     }

newInstance() 主要做了三件事：

  • 1.权限检测，如果不通过直接抛出异常；
  • 2.查找无参构造器，并将其缓存起来；
  • 3.调用具体方法的无参构造方法，生成实例并返回；
    下面是获取构造器的过程：
  1.     private Constructor<T> getConstructor0(Class<?>[] parameterTypes,
  2.                                         int which) throws NoSuchMethodException
  3.     {
  4.         // 获取所有构造器
  5.         Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));
  6.         for (Constructor<T> constructor : constructors) {
  7.             if (arrayContentsEq(parameterTypes,
  8.                                 constructor.getParameterTypes())) {
  9.                 return getReflectionFactory().copyConstructor(constructor);
  10.             }
  11.         }
  12.         throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes));
  13.     }

getConstructor0()为获取匹配的构造方器；分三步：

  • 1.先获取所有的constructors, 然后通过进行参数类型比较；
  • 2.找到匹配后，通过ReflectionFactory copy一份constructor返回；
  • 3.否则抛出NoSuchMethodException;
  2.     // 获取当前类所有的构造方法，通过jvm或者缓存
  3.     // Returns an array of "root" constructors. These Constructor
  4.     // objects must NOT be propagated to the outside world, but must
  5.     // instead be copied via ReflectionFactory.copyConstructor.
  6.     private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
  7.         checkInitted();
  8.         Constructor<T>[] res;
  9.         // 调用 reflectionData(), 获取保存的信息，使用软引用保存，从而使内存不够可以回收
  10.         ReflectionData<T> rd = reflectionData();
  11.         if (rd != null) {
  12.             res = publicOnly ? rd.publicConstructors : rd.declaredConstructors;
  13.             // 存在缓存，则直接返回
  14.             if (res != null) return res;
  15.         }
  16.         // No cached value available; request value from VM
  17.         if (isInterface()) {
  18.             @SuppressWarnings("unchecked")
  19.             Constructor<T>[] temporaryRes = (Constructor<T>[]) new Constructor<?>[0];
  20.             res = temporaryRes;
  21.         } else {
  22.             // 使用native方法从jvm获取构造器
  23.             res = getDeclaredConstructors0(publicOnly);
  24.         }
  25.         if (rd != null) {
  26.             // 最后，将从jvm中读取的内容，存入缓存
  27.             if (publicOnly) {
  28.                 rd.publicConstructors = res;
  29.             } else {
  30.                 rd.declaredConstructors = res;
  31.             }
  32.         }
  33.         return res;
  34.     }
  36.     // Lazily create and cache ReflectionData
  37.     private ReflectionData<T> reflectionData() {
  38.         SoftReference<ReflectionData<T>> reflectionData = this.reflectionData;
  39.         int classRedefinedCount = this.classRedefinedCount;
  40.         ReflectionData<T> rd;
  41.         if (useCaches &&
  42.             reflectionData != null &&
  43.             (rd = reflectionData.get()) != null &&
  44.             rd.redefinedCount == classRedefinedCount) {
  45.             return rd;
  46.         }
  47.         // else no SoftReference or cleared SoftReference or stale ReflectionData
  48.         // -> create and replace new instance
  49.         return newReflectionData(reflectionData, classRedefinedCount);
  50.     }
  52.     // 新创建缓存，保存反射信息
  53.     private ReflectionData<T> newReflectionData(SoftReference<ReflectionData<T>> oldReflectionData,
  54.                                                 int classRedefinedCount) {
  55.         if (!useCaches) return null;
  57.         // 使用cas保证更新的线程安全性，所以反射是保证线程安全的
  58.         while (true) {
  59.             ReflectionData<T> rd = new ReflectionData<>(classRedefinedCount);
  60.             // try to CAS it...
  61.             if (Atomic.casReflectionData(this, oldReflectionData, new SoftReference<>(rd))) {
  62.                 return rd;
  63.             }
  64.             // 先使用CAS更新，如果更新成功，则立即返回，否则测查当前已被其他线程更新的情况，如果和自己想要更新的状态一致，则也算是成功了
  65.             oldReflectionData = this.reflectionData;
  66.             classRedefinedCount = this.classRedefinedCount;
  67.             if (oldReflectionData != null &&
  68.                 (rd = oldReflectionData.get()) != null &&
  69.                 rd.redefinedCount == classRedefinedCount) {
  70.                 return rd;
  71.             }
  72.         }
  73.     }

如上，privateGetDeclaredConstructors(), 获取所有的构造器主要步骤；

  • 1.先尝试从缓存中获取；
  • 2.如果缓存没有，则从jvm中重新获取，并存入缓存，缓存使用软引用进行保存，保证内存可用；
    另外，使用relactionData()进行缓存保存；ReflectionData的数据结构如下。
  2.     // reflection data that might get invalidated when JVM TI RedefineClasses() is called
  3.     private static class ReflectionData<T> {
  4.         volatile Field[] declaredFields;
  5.         volatile Field[] publicFields;
  6.         volatile Method[] declaredMethods;
  7.         volatile Method[] publicMethods;
  8.         volatile Constructor<T>[] declaredConstructors;
  9.         volatile Constructor<T>[] publicConstructors;
  10.         // Intermediate results for getFields and getMethods
  11.         volatile Field[] declaredPublicFields;
  12.         volatile Method[] declaredPublicMethods;
  13.         volatile Class<?>[] interfaces;
  15.         // Value of classRedefinedCount when we created this ReflectionData instance
  16.         final int redefinedCount;
  18.         ReflectionData(int redefinedCount) {
  19.             this.redefinedCount = redefinedCount;
  20.         }
  21.     }

其中，还有一个点，就是如何比较构造是否是要查找构造器，其实就是比较类型完成相等就完了，有一个不相等则返回false。

  1.     private static boolean arrayContentsEq(Object[] a1, Object[] a2) {
  2.         if (a1 == null) {
  3.             return a2 == null || a2.length == 0;
  4.         }
  6.         if (a2 == null) {
  7.             return a1.length == 0;
  8.         }
  10.         if (a1.length != a2.length) {
  11.             return false;
  12.         }
  14.         for (int i = 0; i < a1.length; i++) {
  15.             if (a1[i] != a2[i]) {
  16.                 return false;
  17.             }
  18.         }
  20.         return true;
  21.     }
  22.     // sun.reflect.ReflectionFactory
  23.     /** Makes a copy of the passed constructor. The returned
  24.         constructor is a "child" of the passed one; see the comments
  25.         in Constructor.java for details. */
  26.     public <T> Constructor<T> copyConstructor(Constructor<T> arg) {
  27.         return langReflectAccess().copyConstructor(arg);
  28.     }
  30.     // java.lang.reflect.Constructor, copy 其实就是新new一个 Constructor 出来
  31.     Constructor<T> copy() {
  32.         // This routine enables sharing of ConstructorAccessor objects
  33.         // among Constructor objects which refer to the same underlying
  34.         // method in the VM. (All of this contortion is only necessary
  35.         // because of the "accessibility" bit in AccessibleObject,
  36.         // which implicitly requires that new java.lang.reflect
  37.         // objects be fabricated for each reflective call on Class
  38.         // objects.)
  39.         if (this.root != null)
  40.             throw new IllegalArgumentException("Can not copy a non-root Constructor");
  42.         Constructor<T> res = new Constructor<>(clazz,
  43.                                                parameterTypes,
  44.                                                exceptionTypes, modifiers, slot,
  45.                                                signature,
  46.                                                annotations,
  47.                                                parameterAnnotations);
  48.         // root 指向当前 constructor
  49.         res.root = this;
  50.         // Might as well eagerly propagate this if already present
  51.         res.constructorAccessor = constructorAccessor;
  52.         return res;
  53.     }

通过上面，获取到Constructor了。
接下来就只需调用其相应构造器的newInstance()，即返回实例了。

  1.     // return tmpConstructor.newInstance((Object[])null); 
  2.     // java.lang.reflect.Constructor
  3.     @CallerSensitive
  4.     public T newInstance(Object ... initargs)
  5.         throws InstantiationException, IllegalAccessException,
  6.                IllegalArgumentException, InvocationTargetException
  7.     {
  8.         if (!override) {
  9.             if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
  10.                 Class<?> caller = Reflection.getCallerClass();
  11.                 checkAccess(caller, clazz, null, modifiers);
  12.             }
  13.         }
  14.         if ((clazz.getModifiers() & Modifier.ENUM) != 0)
  15.             throw new IllegalArgumentException("Cannot reflectively create enum objects");
  16.         ConstructorAccessor ca = constructorAccessor;   // read volatile
  17.         if (ca == null) {
  18.             ca = acquireConstructorAccessor();
  19.         }
  20.         @SuppressWarnings("unchecked")
  21.         T inst = (T) ca.newInstance(initargs);
  22.         return inst;
  23.     }
  24.     // sun.reflect.DelegatingConstructorAccessorImpl
  25.     public Object newInstance(Object[] args)
  26.       throws InstantiationException,
  27.              IllegalArgumentException,
  28.              InvocationTargetException
  29.     {
  30.         return delegate.newInstance(args);
  31.     }
  32.     // sun.reflect.NativeConstructorAccessorImpl
  33.     public Object newInstance(Object[] args)
  34.         throws InstantiationException,
  35.                IllegalArgumentException,
  36.                InvocationTargetException
  37.     {
  38.         // We can't inflate a constructor belonging to a vm-anonymous class
  39.         // because that kind of class can't be referred to by name, hence can't
  40.         // be found from the generated bytecode.
  41.         if (++numInvocations > ReflectionFactory.inflationThreshold()
  42.                 && !ReflectUtil.isVMAnonymousClass(c.getDeclaringClass())) {
  43.             ConstructorAccessorImpl acc = (ConstructorAccessorImpl)
  44.                 new MethodAccessorGenerator().
  45.                     generateConstructor(c.getDeclaringClass(),
  46.                                         c.getParameterTypes(),
  47.                                         c.getExceptionTypes(),
  48.                                         c.getModifiers());
  49.             parent.setDelegate(acc);
  50.         }
  52.         // 调用native方法，进行调用 constructor
  53.         return newInstance0(c, args);
  54.     }

返回构造器的实例后，可以根据外部进行进行类型转换，从而使用接口或方法进行调用实例功能了。

反射获取方法

  • 第一步，先获取 Method;
  1.     // java.lang.Class
  2.     @CallerSensitive
  3.     public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
  4.         throws NoSuchMethodException, SecurityException {
  5.         checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
  6.         Method method = searchMethods(privateGetDeclaredMethods(false), name, parameterTypes);
  7.         if (method == null) {
  8.             throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
  9.         }
  10.         return method;
  11.     }

忽略第一个检查权限，剩下就只有两个动作了。

  • 1.获取所有方法列表；
  • 2.根据方法名称和方法列表，选出符合要求的方法；
  • 3.如果没有找到相应方法，抛出异常，否则返回对应方法；
    所以，先看一下怎样获取类声明的所有方法？
  1.     // Returns an array of "root" methods. These Method objects must NOT
  2.     // be propagated to the outside world, but must instead be copied
  3.     // via ReflectionFactory.copyMethod.
  4.     private Method[] privateGetDeclaredMethods(boolean publicOnly) {
  5.         checkInitted();
  6.         Method[] res;
  7.         ReflectionData<T> rd = reflectionData();
  8.         if (rd != null) {
  9.             res = publicOnly ? rd.declaredPublicMethods : rd.declaredMethods;
  10.             if (res != null) return res;
  11.         }
  12.         // No cached value available; request value from VM
  13.         res = Reflection.filterMethods(this, getDeclaredMethods0(publicOnly));
  14.         if (rd != null) {
  15.             if (publicOnly) {
  16.                 rd.declaredPublicMethods = res;
  17.             } else {
  18.                 rd.declaredMethods = res;
  19.             }
  20.         }
  21.         return res;
  22.     }

很相似，和获取所有构造器的方法很相似，都是先从缓存中获取方法，如果没有，则从jvm中获取。
不同的是，方法列表需要进行过滤Reflection.filterMethods;当然后面看来，这个方法我们一般不会派上用场。

  2.     // sun.misc.Reflection
  3.     public static Method[] filterMethods(Class<?> containingClass, Method[] methods) {
  4.         if (methodFilterMap == null) {
  5.             // Bootstrapping
  6.             return methods;
  7.         }
  8.         return (Method[])filter(methods, methodFilterMap.get(containingClass));
  9.     }
  10.     // 可以过滤指定的方法，一般为空，如果要指定过滤，可以调用 registerMethodsToFilter(), 或者...
  11.     private static Member[] filter(Member[] members, String[] filteredNames) {
  12.         if ((filteredNames == null) || (members.length == 0)) {
  13.             return members;
  14.         }
  15.         int numNewMembers = 0;
  16.         for (Member member : members) {
  17.             boolean shouldSkip = false;
  18.             for (String filteredName : filteredNames) {
  19.                 if (member.getName() == filteredName) {
  20.                     shouldSkip = true;
  21.                     break;
  22.                 }
  23.             }
  24.             if (!shouldSkip) {
  25.                 ++numNewMembers;
  26.             }
  27.         }
  28.         Member[] newMembers =
  29.             (Member[])Array.newInstance(members[0].getClass(), numNewMembers);
  30.         int destIdx = 0;
  31.         for (Member member : members) {
  32.             boolean shouldSkip = false;
  33.             for (String filteredName : filteredNames) {
  34.                 if (member.getName() == filteredName) {
  35.                     shouldSkip = true;
  36.                     break;
  37.                 }
  38.             }
  39.             if (!shouldSkip) {
  40.                 newMembers[destIdx++] = member;
  41.             }
  42.         }
  43.         return newMembers;
  44.     }
  • 第二步，根据方法名和参数类型过滤指定方法返回：
  1.     private static Method searchMethods(Method[] methods,
  2.                                         String name,
  3.                                         Class<?>[] parameterTypes)
  4.     {
  5.         Method res = null;
  6.         // 使用常量池，避免重复创建String
  7.         String internedName = name.intern();
  8.         for (int i = 0; i < methods.length; i++) {
  9.             Method m = methods[i];
  10.             if (m.getName() == internedName
  11.                 && arrayContentsEq(parameterTypes, m.getParameterTypes())
  12.                 && (res == null
  13.                     || res.getReturnType().isAssignableFrom(m.getReturnType())))
  14.                 res = m;
  15.         }
  17.         return (res == null ? res : getReflectionFactory().copyMethod(res));
  18.     }

概意思看得明白，就是匹配到方法名，然后参数类型匹配，才可以。

  • 但是可以看到，匹配到一个方法，并没有退出for循环，而是继续进行匹配。
  • 这里是匹配最精确的子类进行返回（最优匹配）
  • 最后，还是通过ReflectionFactory, copy方法后返回。

调用method.invoke()方法

  1.     @CallerSensitive
  2.     public Object invoke(Object obj, Object... args)
  3.         throws IllegalAccessException, IllegalArgumentException,
  4.            InvocationTargetException
  5.     {
  6.         if (!override) {
  7.             if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
  8.                 Class<?> caller = Reflection.getCallerClass();
  9.                 checkAccess(caller, clazz, obj, modifiers);
  10.             }
  11.         }
  12.         MethodAccessor ma = methodAccessor;             // read volatile
  13.         if (ma == null) {
  14.             ma = acquireMethodAccessor();
  15.         }
  16.         return ma.invoke(obj, args);
  17.     }

invoke时，是通过MethodAccessor进行调用的，而MethodAccessor是个接口，在第一次时调用acquireMethodAccessor()进行新创建。

  1.     // probably make the implementation more scalable.
  2.     private MethodAccessor acquireMethodAccessor() {
  3.         // First check to see if one has been created yet, and take it
  4.         // if so
  5.         MethodAccessor tmp = null;
  6.         if (root != null) tmp = root.getMethodAccessor();
  7.         if (tmp != null) {
  8.             // 存在缓存时，存入 methodAccessor，否则调用 ReflectionFactory 创建新的 MethodAccessor
  9.             methodAccessor = tmp;
  10.         } else {
  11.             // Otherwise fabricate one and propagate it up to the root
  12.             tmp = reflectionFactory.newMethodAccessor(this);
  13.             setMethodAccessor(tmp);
  14.         }
  16.         return tmp;
  17.     }
  18.     // sun.reflect.ReflectionFactory
  19.     public MethodAccessor newMethodAccessor(Method method) {
  20.         checkInitted();
  22.         if (noInflation && !ReflectUtil.isVMAnonymousClass(method.getDeclaringClass())) {
  23.             return new MethodAccessorGenerator().
  24.                 generateMethod(method.getDeclaringClass(),
  25.                                method.getName(),
  26.                                method.getParameterTypes(),
  27.                                method.getReturnType(),
  28.                                method.getExceptionTypes(),
  29.                                method.getModifiers());
  30.         } else {
  31.             NativeMethodAccessorImpl acc =
  32.                 new NativeMethodAccessorImpl(method);
  33.             DelegatingMethodAccessorImpl res =
  34.                 new DelegatingMethodAccessorImpl(acc);
  35.             acc.setParent(res);
  36.             return res;
  37.         }
  38.     }

两个Accessor详情：

  2. //     NativeMethodAccessorImpl / DelegatingMethodAccessorImpl
  3. class NativeMethodAccessorImpl extends MethodAccessorImpl {
  4.     private final Method method;
  5.     private DelegatingMethodAccessorImpl parent;
  6.     private int numInvocations;
  8.     NativeMethodAccessorImpl(Method method) {
  9.         this.method = method;
  10.     }
  12.     public Object invoke(Object obj, Object[] args)
  13.         throws IllegalArgumentException, InvocationTargetException
  14.     {
  15.         // We can't inflate methods belonging to vm-anonymous classes because
  16.         // that kind of class can't be referred to by name, hence can't be
  17.         // found from the generated bytecode.
  18.         if (++numInvocations > ReflectionFactory.inflationThreshold()
  19.                 && !ReflectUtil.isVMAnonymousClass(method.getDeclaringClass())) {
  20.             MethodAccessorImpl acc = (MethodAccessorImpl)
  21.                 new MethodAccessorGenerator().
  22.                     generateMethod(method.getDeclaringClass(),
  23.                                    method.getName(),
  24.                                    method.getParameterTypes(),
  25.                                    method.getReturnType(),
  26.                                    method.getExceptionTypes(),
  27.                                    method.getModifiers());
  28.             parent.setDelegate(acc);
  29.         }
  31.         return invoke0(method, obj, args);
  32.     }
  34.     void setParent(DelegatingMethodAccessorImpl parent) {
  35.         this.parent = parent;
  36.     }
  38.     private static native Object invoke0(Method m, Object obj, Object[] args);
  39. }
  40. class DelegatingMethodAccessorImpl extends MethodAccessorImpl {
  41.     private MethodAccessorImpl delegate;
  43.     DelegatingMethodAccessorImpl(MethodAccessorImpl delegate) {
  44.         setDelegate(delegate);
  45.     }
  47.     public Object invoke(Object obj, Object[] args)
  48.         throws IllegalArgumentException, InvocationTargetException
  49.     {
  50.         return delegate.invoke(obj, args);
  51.     }
  53.     void setDelegate(MethodAccessorImpl delegate) {
  54.         this.delegate = delegate;
  55.     }
  56. }

进行ma.invoke(obj, args); 调用时，调用DelegatingMethodAccessorImpl.invoke();
最后被委托到NativeMethodAccessorImpl.invoke(), 即：

  1.     public Object invoke(Object obj, Object[] args)
  2.         throws IllegalArgumentException, InvocationTargetException
  3.     {
  4.         // We can't inflate methods belonging to vm-anonymous classes because
  5.         // that kind of class can't be referred to by name, hence can't be
  6.         // found from the generated bytecode.
  7.         if (++numInvocations > ReflectionFactory.inflationThreshold()
  8.                 && !ReflectUtil.isVMAnonymousClass(method.getDeclaringClass())) {
  9.             MethodAccessorImpl acc = (MethodAccessorImpl)
  10.                 new MethodAccessorGenerator().
  11.                     generateMethod(method.getDeclaringClass(),
  12.                                    method.getName(),
  13.                                    method.getParameterTypes(),
  14.                                    method.getReturnType(),
  15.                                    method.getExceptionTypes(),
  16.                                    method.getModifiers());
  17.             parent.setDelegate(acc);
  18.         }
  20.         // invoke0 是个 native 方法，由jvm进行调用业务方法。从而完成反射调用功能。
  21.         return invoke0(method, obj, args);
  22.     }

其中，generateMethod()是生成具体类的方法：

  1.     /** This routine is not thread-safe */
  2.     public MethodAccessor generateMethod(Class<?> declaringClass,
  3.                                          String   name,
  4.                                          Class<?>[] parameterTypes,
  5.                                          Class<?>   returnType,
  6.                                          Class<?>[] checkedExceptions,
  7.                                          int modifiers)
  8.     {
  9.         return (MethodAccessor) generate(declaringClass,
  10.                                          name,
  11.                                          parameterTypes,
  12.                                          returnType,
  13.                                          checkedExceptions,
  14.                                          modifiers,
  15.                                          false,
  16.                                          false,
  17.                                          null);
  18.     }

generate()戳详情。

  1.     /** This routine is not thread-safe */
  2.     private MagicAccessorImpl generate(final Class<?> declaringClass,
  3.                                        String name,
  4.                                        Class<?>[] parameterTypes,
  5.                                        Class<?>   returnType,
  6.                                        Class<?>[] checkedExceptions,
  7.                                        int modifiers,
  8.                                        boolean isConstructor,
  9.                                        boolean forSerialization,
  10.                                        Class<?> serializationTargetClass)
  11.     {
  12.         ByteVector vec = ByteVectorFactory.create();
  13.         asm = new ClassFileAssembler(vec);
  14.         this.declaringClass = declaringClass;
  15.         this.parameterTypes = parameterTypes;
  16.         this.returnType = returnType;
  17.         this.modifiers = modifiers;
  18.         this.isConstructor = isConstructor;
  19.         this.forSerialization = forSerialization;
  21.         asm.emitMagicAndVersion();
  23.         // Constant pool entries:
  24.         // ( * = Boxing information: optional)
  25.         // (+  = Shared entries provided by AccessorGenerator)
  26.         // (^  = Only present if generating SerializationConstructorAccessor)
  27.         //     [UTF-8] [This class's name]
  28.         //     [CONSTANT_Class_info] for above
  29.         //     [UTF-8] "sun/reflect/{MethodAccessorImpl,ConstructorAccessorImpl,SerializationConstructorAccessorImpl}"
  30.         //     [CONSTANT_Class_info] for above
  31.         //     [UTF-8] [Target class's name]
  32.         //     [CONSTANT_Class_info] for above
  33.         // ^   [UTF-8] [Serialization: Class's name in which to invoke constructor]
  34.         // ^   [CONSTANT_Class_info] for above
  35.         //     [UTF-8] target method or constructor name
  36.         //     [UTF-8] target method or constructor signature
  37.         //     [CONSTANT_NameAndType_info] for above
  38.         //     [CONSTANT_Methodref_info or CONSTANT_InterfaceMethodref_info] for target method
  39.         //     [UTF-8] "invoke" or "newInstance"
  40.         //     [UTF-8] invoke or newInstance descriptor
  41.         //     [UTF-8] descriptor for type of non-primitive parameter 1
  42.         //     [CONSTANT_Class_info] for type of non-primitive parameter 1
  43.         //     ...
  44.         //     [UTF-8] descriptor for type of non-primitive parameter n
  45.         //     [CONSTANT_Class_info] for type of non-primitive parameter n
  46.         // +   [UTF-8] "java/lang/Exception"
  47.         // +   [CONSTANT_Class_info] for above
  48.         // +   [UTF-8] "java/lang/ClassCastException"
  49.         // +   [CONSTANT_Class_info] for above
  50.         // +   [UTF-8] "java/lang/NullPointerException"
  51.         // +   [CONSTANT_Class_info] for above
  52.         // +   [UTF-8] "java/lang/IllegalArgumentException"
  53.         // +   [CONSTANT_Class_info] for above
  54.         // +   [UTF-8] "java/lang/InvocationTargetException"
  55.         // +   [CONSTANT_Class_info] for above
  56.         // +   [UTF-8] "<init>"
  57.         // +   [UTF-8] "()V"
  58.         // +   [CONSTANT_NameAndType_info] for above
  59.         // +   [CONSTANT_Methodref_info] for NullPointerException's constructor
  60.         // +   [CONSTANT_Methodref_info] for IllegalArgumentException's constructor
  61.         // +   [UTF-8] "(Ljava/lang/String;)V"
  62.         // +   [CONSTANT_NameAndType_info] for "<init>(Ljava/lang/String;)V"
  63.         // +   [CONSTANT_Methodref_info] for IllegalArgumentException's constructor taking a String
  64.         // +   [UTF-8] "(Ljava/lang/Throwable;)V"
  65.         // +   [CONSTANT_NameAndType_info] for "<init>(Ljava/lang/Throwable;)V"
  66.         // +   [CONSTANT_Methodref_info] for InvocationTargetException's constructor
  67.         // +   [CONSTANT_Methodref_info] for "super()"
  68.         // +   [UTF-8] "java/lang/Object"
  69.         // +   [CONSTANT_Class_info] for above
  70.         // +   [UTF-8] "toString"
  71.         // +   [UTF-8] "()Ljava/lang/String;"
  72.         // +   [CONSTANT_NameAndType_info] for "toString()Ljava/lang/String;"
  73.         // +   [CONSTANT_Methodref_info] for Object's toString method
  74.         // +   [UTF-8] "Code"
  75.         // +   [UTF-8] "Exceptions"
  76.         //  *  [UTF-8] "java/lang/Boolean"
  77.         //  *  [CONSTANT_Class_info] for above
  78.         //  *  [UTF-8] "(Z)V"
  79.         //  *  [CONSTANT_NameAndType_info] for above
  80.         //  *  [CONSTANT_Methodref_info] for above
  81.         //  *  [UTF-8] "booleanValue"
  82.         //  *  [UTF-8] "()Z"
  83.         //  *  [CONSTANT_NameAndType_info] for above
  84.         //  *  [CONSTANT_Methodref_info] for above
  85.         //  *  [UTF-8] "java/lang/Byte"
  86.         //  *  [CONSTANT_Class_info] for above
  87.         //  *  [UTF-8] "(B)V"
  88.         //  *  [CONSTANT_NameAndType_info] for above
  89.         //  *  [CONSTANT_Methodref_info] for above
  90.         //  *  [UTF-8] "byteValue"
  91.         //  *  [UTF-8] "()B"
  92.         //  *  [CONSTANT_NameAndType_info] for above
  93.         //  *  [CONSTANT_Methodref_info] for above
  94.         //  *  [UTF-8] "java/lang/Character"
  95.         //  *  [CONSTANT_Class_info] for above
  96.         //  *  [UTF-8] "(C)V"
  97.         //  *  [CONSTANT_NameAndType_info] for above
  98.         //  *  [CONSTANT_Methodref_info] for above
  99.         //  *  [UTF-8] "charValue"
  100.         //  *  [UTF-8] "()C"
  101.         //  *  [CONSTANT_NameAndType_info] for above
  102.         //  *  [CONSTANT_Methodref_info] for above
  103.         //  *  [UTF-8] "java/lang/Double"
  104.         //  *  [CONSTANT_Class_info] for above
  105.         //  *  [UTF-8] "(D)V"
  106.         //  *  [CONSTANT_NameAndType_info] for above
  107.         //  *  [CONSTANT_Methodref_info] for above
  108.         //  *  [UTF-8] "doubleValue"
  109.         //  *  [UTF-8] "()D"
  110.         //  *  [CONSTANT_NameAndType_info] for above
  111.         //  *  [CONSTANT_Methodref_info] for above
  112.         //  *  [UTF-8] "java/lang/Float"
  113.         //  *  [CONSTANT_Class_info] for above
  114.         //  *  [UTF-8] "(F)V"
  115.         //  *  [CONSTANT_NameAndType_info] for above
  116.         //  *  [CONSTANT_Methodref_info] for above
  117.         //  *  [UTF-8] "floatValue"
  118.         //  *  [UTF-8] "()F"
  119.         //  *  [CONSTANT_NameAndType_info] for above
  120.         //  *  [CONSTANT_Methodref_info] for above
  121.         //  *  [UTF-8] "java/lang/Integer"
  122.         //  *  [CONSTANT_Class_info] for above
  123.         //  *  [UTF-8] "(I)V"
  124.         //  *  [CONSTANT_NameAndType_info] for above
  125.         //  *  [CONSTANT_Methodref_info] for above
  126.         //  *  [UTF-8] "intValue"
  127.         //  *  [UTF-8] "()I"
  128.         //  *  [CONSTANT_NameAndType_info] for above
  129.         //  *  [CONSTANT_Methodref_info] for above
  130.         //  *  [UTF-8] "java/lang/Long"
  131.         //  *  [CONSTANT_Class_info] for above
  132.         //  *  [UTF-8] "(J)V"
  133.         //  *  [CONSTANT_NameAndType_info] for above
  134.         //  *  [CONSTANT_Methodref_info] for above
  135.         //  *  [UTF-8] "longValue"
  136.         //  *  [UTF-8] "()J"
  137.         //  *  [CONSTANT_NameAndType_info] for above
  138.         //  *  [CONSTANT_Methodref_info] for above
  139.         //  *  [UTF-8] "java/lang/Short"
  140.         //  *  [CONSTANT_Class_info] for above
  141.         //  *  [UTF-8] "(S)V"
  142.         //  *  [CONSTANT_NameAndType_info] for above
  143.         //  *  [CONSTANT_Methodref_info] for above
  144.         //  *  [UTF-8] "shortValue"
  145.         //  *  [UTF-8] "()S"
  146.         //  *  [CONSTANT_NameAndType_info] for above
  147.         //  *  [CONSTANT_Methodref_info] for above
  149.         short numCPEntries = NUM_BASE_CPOOL_ENTRIES + NUM_COMMON_CPOOL_ENTRIES;
  150.         boolean usesPrimitives = usesPrimitiveTypes();
  151.         if (usesPrimitives) {
  152.             numCPEntries += NUM_BOXING_CPOOL_ENTRIES;
  153.         }
  154.         if (forSerialization) {
  155.             numCPEntries += NUM_SERIALIZATION_CPOOL_ENTRIES;
  156.         }
  158.         // Add in variable-length number of entries to be able to describe
  159.         // non-primitive parameter types and checked exceptions.
  160.         numCPEntries += (short) (2 * numNonPrimitiveParameterTypes());
  162.         asm.emitShort(add(numCPEntries, S1));
  164.         final String generatedName = generateName(isConstructor, forSerialization);
  165.         asm.emitConstantPoolUTF8(generatedName);
  166.         asm.emitConstantPoolClass(asm.cpi());
  167.         thisClass = asm.cpi();
  168.         if (isConstructor) {
  169.             if (forSerialization) {
  170.                 asm.emitConstantPoolUTF8
  171.                     ("sun/reflect/SerializationConstructorAccessorImpl");
  172.             } else {
  173.                 asm.emitConstantPoolUTF8("sun/reflect/ConstructorAccessorImpl");
  174.             }
  175.         } else {
  176.             asm.emitConstantPoolUTF8("sun/reflect/MethodAccessorImpl");
  177.         }
  178.         asm.emitConstantPoolClass(asm.cpi());
  179.         superClass = asm.cpi();
  180.         asm.emitConstantPoolUTF8(getClassName(declaringClass, false));
  181.         asm.emitConstantPoolClass(asm.cpi());
  182.         targetClass = asm.cpi();
  183.         short serializationTargetClassIdx = (short) 0;
  184.         if (forSerialization) {
  185.             asm.emitConstantPoolUTF8(getClassName(serializationTargetClass, false));
  186.             asm.emitConstantPoolClass(asm.cpi());
  187.             serializationTargetClassIdx = asm.cpi();
  188.         }
  189.         asm.emitConstantPoolUTF8(name);
  190.         asm.emitConstantPoolUTF8(buildInternalSignature());
  191.         asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
  192.         if (isInterface()) {
  193.             asm.emitConstantPoolInterfaceMethodref(targetClass, asm.cpi());
  194.         } else {
  195.             if (forSerialization) {
  196.                 asm.emitConstantPoolMethodref(serializationTargetClassIdx, asm.cpi());
  197.             } else {
  198.                 asm.emitConstantPoolMethodref(targetClass, asm.cpi());
  199.             }
  200.         }
  201.         targetMethodRef = asm.cpi();
  202.         if (isConstructor) {
  203.             asm.emitConstantPoolUTF8("newInstance");
  204.         } else {
  205.             asm.emitConstantPoolUTF8("invoke");
  206.         }
  207.         invokeIdx = asm.cpi();
  208.         if (isConstructor) {
  209.             asm.emitConstantPoolUTF8("([Ljava/lang/Object;)Ljava/lang/Object;");
  210.         } else {
  211.             asm.emitConstantPoolUTF8
  212.                 ("(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;");
  213.         }
  214.         invokeDescriptorIdx = asm.cpi();
  216.         // Output class information for non-primitive parameter types
  217.         nonPrimitiveParametersBaseIdx = add(asm.cpi(), S2);
  218.         for (int i = 0; i < parameterTypes.length; i++) {
  219.             Class<?> c = parameterTypes[i];
  220.             if (!isPrimitive(c)) {
  221.                 asm.emitConstantPoolUTF8(getClassName(c, false));
  222.                 asm.emitConstantPoolClass(asm.cpi());
  223.             }
  224.         }
  226.         // Entries common to FieldAccessor, MethodAccessor and ConstructorAccessor
  227.         emitCommonConstantPoolEntries();
  229.         // Boxing entries
  230.         if (usesPrimitives) {
  231.             emitBoxingContantPoolEntries();
  232.         }
  234.         if (asm.cpi() != numCPEntries) {
  235.             throw new InternalError("Adjust this code (cpi = " + asm.cpi() +
  236.                                     ", numCPEntries = " + numCPEntries + ")");
  237.         }
  239.         // Access flags
  240.         asm.emitShort(ACC_PUBLIC);
  242.         // This class
  243.         asm.emitShort(thisClass);
  245.         // Superclass
  246.         asm.emitShort(superClass);
  248.         // Interfaces count and interfaces
  249.         asm.emitShort(S0);
  251.         // Fields count and fields
  252.         asm.emitShort(S0);
  254.         // Methods count and methods
  255.         asm.emitShort(NUM_METHODS);
  257.         emitConstructor();
  258.         emitInvoke();
  260.         // Additional attributes (none)
  261.         asm.emitShort(S0);
  263.         // Load class
  264.         vec.trim();
  265.         final byte[] bytes = vec.getData();
  266.         // Note: the class loader is the only thing that really matters
  267.         // here -- it's important to get the generated code into the
  268.         // same namespace as the target class. Since the generated code
  269.         // is privileged anyway, the protection domain probably doesn't
  270.         // matter.
  271.         return AccessController.doPrivileged(
  272.             new PrivilegedAction<MagicAccessorImpl>() {
  273.                 public MagicAccessorImpl run() {
  274.                         try {
  275.                         return (MagicAccessorImpl)
  276.                         ClassDefiner.defineClass
  277.                                 (generatedName,
  278.                                  bytes,
  279.                                  0,
  280.                                  bytes.length,
  281.                                  declaringClass.getClassLoader()).newInstance();
  282.                         } catch (InstantiationException | IllegalAccessException e) {
  283.                             throw new InternalError(e);
  284.                         }
  285.                     }
  286.                 });
  287.     }

咱们主要看这一句：ClassDefiner.defineClass(xx, declaringClass.getClassLoader()).newInstance();
在ClassDefiner.defineClass方法实现中，每被调用一次都会生成一个DelegatingClassLoader类加载器对象，这里每次都生成新的类加载器，是为了性能考虑，在某些情况下可以卸载这些生成的类，因为类的卸载是只有在类加载器可以被回收的情况下才会被回收的，如果用了原来的类加载器，那可能导致这些新创建的类一直无法被卸载。
而反射生成的类，有时候可能用了就可以卸载了，所以使用其独立的类加载器，从而使得更容易控制反射类的生命周期。

反射调用流程小结

最后，用几句话总结反射的实现原理：

  1. 反射类及反射方法的获取，都是通过从列表中搜寻查找匹配的方法，所以查找性能会随类的大小方法多少而变化；
  2. 每个类都会有一个与之对应的Class实例，从而每个类都可以获取method反射方法，并作用到其他实例身上；
  3. 反射也是考虑了线程安全的，放心使用；
  4. 反射使用软引用relectionData缓存class信息，避免每次重新从jvm获取带来的开销；
  5. 反射调用多次生成新代理Accessor, 而通过字节码生存的则考虑了卸载功能，所以会使用独立的类加载器；
  6. 当找到需要的方法，都会copy一份出来，而不是使用原来的实例，从而保证数据隔离；
  7. 调度反射方法，最终是由jvm执行invoke0()执行；