1. Java反射简介

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法,并且可以动态生成一个对象然后调用它的任意一个方法；

这种动态获取类的信息以及动态生成对象并调用对象的方法的功能称为Java语言的反射机制。

Java反射机制是Java语言被视为“准动态”语言的关键性质。

Java反射机制的核心就是允许在运行时通过Java Reflection APIs来取得已知名字的class类的内部信息(包括其modifiers(诸如public, static等等)、superclass(例如Object)、实现interfaces(例如Serializable)，也包括fields和methods的所有信息)，动态地生成此类对象，并调用其方法或修改其域（甚至是本身声明为private的域或方法）。

2. Class对象

Class对象是Java反射的基础，它包含了与类相关的信息，事实上，Class对象就是用来创建类的所有对象的。Class对象是java.lang.Class<T>这个类生成的对象，其中类型参数T表示由此 Class 对象建模的类的类型。例如，String.class的类型是 Class<String>；如果将被建模的类未知，则使用Class<?>。以下是Java API的描述：

Class类的实例表示正在运行的 Java应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为Class对象的一个类，所有具有相同元素类型和维数的数组都共享该Class对象。基本的Java类型（boolean、byte、char、short、int、long、float和double）和关键字void也表示为Class对象。

Class没有公共构造方法。Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的。

实际上，每个类都有一个Class对象。换言之，每当编写并且编译了一个新类，就会产生一个Class对象(更恰当的说，是被保存在一个同名的.class文件中)。如果我们想生成这个类的对象，运行这个程序的Java虚拟机(JVM)将使用类加载器子系统，类加载器首先检查这个类的Class对象是否已经加载。如果尚未加载，默认的类加载器就会根据类名查找.class文件，并将其载入，一旦某个类的Class对象被载入内存，它就被用来创建这个类的所有对象。

获取Class对象有三种方式：

(1)    通过实例变量的getClass()方法。例如：

Class c1 = new String("abc").getClass();

(2)    通过Class类的静态方法——forName()来实现，例如：

Class class =Class.forName(className);

注意：当使用Class.forName()方法时，你必须提供完全限定类名。即类名要包括所有包

名。例如，如果MyObject是位于包com.jenkov.myapp下,那么类的完全限定名称是com.jenkov.myapp.MyObject。如果在运行时类路径上找不到类，Class.forName()方法会抛出一个ClassNotFoundException。

(3)  使用类字面常量或TYPE字段，例如：

Class myObjectClass= MyObject.class；(类字面常量不仅可以应用于普通的类，也可以应用

于接口、数组以及基本数据类型)，这种方式不仅更简单，而且更安全，因为它在编译时就会受到检查，并且根除了对forName方法的调用，所以也更高效，建议使用“.class”的形式。

Class c = Integer.TYPE；（TYPE是基本数据类型的包装类型的一个标准字段，它是一

个引用，指向对应的基本数据类型的Class对象），附表如下，两边等价：

3. 类

使用Java反射，你可以在运行时检查Java类。检查类是使用反射时经常做的第一件事情。从类中可以获取以下信息：

(1) 类名

(2) 类修饰符 (public, private, synchronized等)

(3) 包信息

(4) 父类

(5) 实现的接口

(6) 构造函数

(7) 方法

(8) 字段

(9) 注解

3.1类名

    从Class对象中可以获取两个不同的类名。完全限定类名(包括包名)可以使用getName()或getCanonicalName()方法获取,例如：

Class aClass = MyObject.class;

String className = aClass.getName();

String className1 = aClass.getCanonicalName();

如果想要获取不含包名的类名可以使用getSimpleName() 方法，如下:

Class  aClass = MyObject.class;

     String simpleClassName = aClass.getSimpleName();

3.2修饰符

使用Class对象可以获取一个类的修饰符.类的修饰符即关键字"public","private", "static"等. 如下：

    Class aClass = MyObject.class;

    int modifiers = aClass.getModifiers();

修饰符被包装进一个int内，每一个修饰符都是一个标志位(置位或清零)。可以使用java.lang.reflect.Modifier类中的以下方法来检验修饰符:

    Modifier.isAbstract(int modifiers)

    Modifier.isFinal(int modifiers)

    Modifier.isInterface(int modifiers)

    Modifier.isNative(int modifiers)

    Modifier.isPrivate(int modifiers)

    Modifier.isProtected(int modifiers)

    Modifier.isPublic(int modifiers)

    Modifier.isStatic(int modifiers)

    Modifier.isStrict(int modifiers)

    Modifier.isSynchronized(int modifiers)

    Modifier.isTransient(int modifiers)

    Modifier.isVolatile(int modifiers)

3.3包信息

使用Class对象可以获取包信息，如下:

Class aClass = MyObject.class;

Package package = aClass.getPackage();

String packageName = package.getname();

从Package对象中你可以访问诸如名字等包信息。您还可以访问类路径上这个包位于JAR文件中Manifest这个文件中指定的信息。例如，你可以在Manifest文件中指定包的版本号。可以在java.lang.Package中了解更多包类信息。

3.4父类

通过Class对象可以获取类的父类，如下:

Class  aClass = MyObject.class;

Class superclass = aClass.getSuperclass();

父类的Class对象和其它Class对象一样是一个Class对象，可以继续使用反射.

3.5实现的接口

通过给定的类可以获取这个类所实现的接口列表，如下:

Class aClass = MyObject.class;

Class[] interfaces = aClass.getInterfaces();

一个类可以实现多个接口。因此返回一个Class数组。在Java反射机制中，接口也由Class对象表示。

注意:只有给定类声明实现的接口才会返回。例如，如果类A的父类B实现了一个接口C，但类A并没有声明它也实现了C，那么C不会被返回到数组中。即使类A实际上实现了接口C，因为它的父类B实现了C。

为了得到一个给定的类实现接口的完整列表，需要递归访问类和其超类。

3.6构造函数

使用Class对象可以获取类的构造函数，如下：

     Class aClass = MyObject.class;

Constructor[] constructors = aClass.getConstructors();

提供四种可供调用的方法:

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数， 

Constructor[] getConstructors( ) -- 获得类的所有公共构造函数 

Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关) 

Constructor[] getDeclaredConstructors( ) -- 获得类的所有构造函数(与接入级别无关) 

3.7方法

使用Class对象可以获取类的方法，如下:

     Class aClass = MyObject.class;

Method[] methods = aClass.getMethods();

获取类中的相关方法就需要用到Method这个API了:

同样也是提供了四个可供调用的方法:

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法 

Method[] getMethods( ) -- 获得类的所有公共方法 

Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法 

Method[] getDeclaredMethods( ) -- 获得类声明的所有方法,不考略权限 

3.8字段

使用Class对象可以获取类的字段(成员变量)，如下:

      Class aClass = MyObject.class;

Field[] fields = aClass.getFields();

获取相关的成员变量则要用到Field这个API了:

也是提供了四种可供调用的方法:

Field getField(String name) -- 获得命名的公共字段 

Field[] getFields( ) -- 获得类的所有公共字段 

Field getDeclaredField(String name) -- 获得类声明的命名的字段 

Field[] getDeclaredFields( ) -- 获得类声明的所有字段 

3.9注解

使用Class对象可以获取类的注解，如下:

      Class aClass = MyObject.class;

Annotation[] annotations = aClass.getAnnotations();

4. 构造函数

使用Java反射可以在运行时检查类的构造函数并实例化对象。这是通过Java类java.lang.reflect.Constructor来实现的。以下是Java Construcor对象的更多细节：

(1) 获取Constructor对象

(2) 构造函数参数

(3) 使用Constructor对象实例化对象

4.1获取Constructor对象

 Constructor类是从Class对象获取的，举例:

Class aClass = MyObject.class;

Constructor[] constructors = aClass.getConstructors();

Constructor数组为每一个在类中声明的public构造函数保存一个Constructor实例。

如果知道要访问的构造函数确切的参数类型，可以不获取构造函数数组。本示例将返回给定类中接受一个字符串作为参数的公共构造函数。

Class aClass = MyObject.class;//MyObject有一个参数为字符串的公共构造函数

Constructor constructor = aClass.getConstructor(new Class[]{String.class});

如果没有匹配给定的构造函数参数，在这个例子当中是String.class，会抛出 NoSuchMethodException 异常.

4.2构造函数参数

可以知道给定的构造函数接受什么参数，如下:

Class aClass = MyObject.class;//MyObject有一个参数为字符串的公共构造函数

Constructor constructor = aClass.getConstructor(new Class[]{String.class});

Class[] parameterTypes = constructor.getParameterTypes();

4.3使用Constructor对象实例化对象

可以像这样实例化对象:

//获取使用字符串作为参数的constructor

Constructor constructor = MyObject.class.getConstructor(String.class);

MyObject myObject = (MyObject)constructor.newInstance("constructor-arg1");

Constructor.newInstance() 方法使用可变长度的参数,但是在调用构造函数时必须为每一个参数提供一个准确的参量.在这个例子中构造函数接受一个字符串作为参数，所以必须要提供一个字符串。

5. 字段

使用Java反射你可以在运行时检查类的字段(成员变量)并 get / set它们.这是通过Java类java.lang.reflect.Field来完成的.以下是JavaField对象更多细节:

(1) 获取Field 对象

(2) 字段名称

(3) 字段类型

(4) 获取和设置字段值

5.1获取Field 对象

     Field类是从Class对象获取的.举例:

Class aClass = MyObject.class;

Field[] methods = aClass.getFields();

Field数组为类中声明的每一个public字段保存一个Field 实例。

如果知道要访问的字段名称,可以这样获取它:

Class aClass = MyObject.class

Field field = aClass.getField("someField");

根据下面 MyObject 声明的someField字段，以上的例子将返回Field实例:

public class MyObject{

       public String someField = null;

}

如果不存在getField()方法中所给参数名字对应的字段,会抛出NoSuchFieldException异常.

5.2字段名称

一旦获得一个 Field实例,可以使用Field.getName()方法获取它的字段名字，如下:

Field field = ... //获取 field 对象

String fieldName = field.getName();

5.3字段类型

你可以使用Field.getType()方法确定一个字段的类型(String,int等):

Field field = aClass.getField("someField");

Object fieldType = field.getType();

5.4获取和设置字段值

一旦获得一个Field引用，可以使用Field.get() 和 Field.set()方法获取和设置它的值，如下:

Class aClass = MyObject.class

Field field = aClass.getField("someField");

MyObject objectInstance = new MyObject();

Object value = field.get(objectInstance);

field.set(objetInstance, value);

传递给get和set方法的对象实例参数应该是拥有该字段的类的一个实例。在上述的例子中使用了MyObject的一个实例，因为someField是MyObject类的一个实例成员。静态字段（public static）给get和set方法传递null作为参数，而不是以上传递的objectInstance参数。

6. 方法

使用Java反射你可以在运行时检查类的方法并调用它们.这是通过Java类java.lang.reflect.Method来实现的.本章将会更详细的介绍 Java Method对象.下面是本章所涵盖的主题:

(1) 获取 Method对象

(2) 方法的参数和返回值类型

(3) 使用Method对象调用方法

6.1获取Method对象

Method类是从 Class 对象中获取的.举例:

Class aClass = MyObject.class;

Method[] methods = aClass.getMethods();

 Method数组将为类中声明的每一个public的方法保存一个Method实例.

如果你知道要访问方法的确切的参数类型，可以不必获取方法数组。本示例返回给定类中接受一个字符串作为参数的公共方法”doSomething”。

Class  aClass = MyObject.class;

Method method = aClass.getMethod("doSomething", new Class[]{String.class});

如果没有方法匹配所给的方法名和参数,在这个例子中是String.class,将抛出NoSuchMethodException异常.

如果你想访问的方法没有参数,传递 null作为参数类型数组,如下:

Class  aClass = MyObject.class;

Method method = aClass.getMethod("doSomething", null);

6.2方法的参数和返回值类型

使用Method对象可以获取方法的参数，如下:

Method method = ... //获取 method – 如上

Class[] parameterTypes = method.getParameterTypes();

亦可以获取方法的返回值类型，如下:

Method method = ... // obtain method - see above

Class returnType = method.getReturnType();

6.3使用Method对象调用方法

可以像这样调用方法:

//get method that takes a String as argument

Method method = MyObject.class.getMethod("doSomething", String.class);

Object returnValue = method.invoke(null, "parameter-value1");

空参数是你想要调用该方法的对象。如果该方法是静态的，使用null，而不是一个对象实例。在这个例子中，如果doSomething（String.class）不是静态的，你需要提供有效的MyObject实例而不是null作为参数;
    Method.invoke(Object target, Object ...parameters)方法接受可变长度的参数，但是你在调用时必须为每一个参数提供一个准确的参量。在这个例子中，方法以字符串作为参数的，所以必须提供一个字符串。

7. get和set方法

    使用Java反射可以在运行时检查类的方法并调用它们。这可以用来检测一个给定的类有哪些get和set方法。可以通过扫描一个类的所有方法并检查每个方法是否是get或set方法。

下面是一段用来找到类的get和set方法的代码:

8. 私有字段和方法

可以通过Java反射访问类的私有字段和方法。

8.1访问私有字段

要想访问私有字段你需要调用Class.getDeclaredField(Stringname)或 Class.getDeclaredFields()方法. Class.getField(String name) 和 Class.getFields()方法仅返回public字段。下面是一个简单的示例，类有一个私有字段，代码通过反射来访问这个私有字段:

public class PrivateObject {

        private String privateString = null;

        public PrivateObject(String privateString) {

           this.privateString = privateString;

        }

}

PrivateObject privateObject = new PrivateObject("The Private Value");

Field privateStringField = PrivateObject.class. getDeclaredField("privateString");

privateStringField.setAccessible(true);

String fieldValue = (String) privateStringField.get(privateObject);

System.out.println("fieldValue = " + fieldValue);

代码示例输出"fieldValue = The Private Value",即代码示例最开始创建的PrivateObject实例的私有字段 privateString的值。

注意PrivateObject.class.getDeclaredField("privateString")的使用。这个方法仅仅返回特定类声明的字段，而不包括任何父类中声明的字段。

注意粗体代码.通过调用Field.setAcessible（true）方法关闭了特定Field实例的访问检查，现在通过反射可以访问它，即使它是私有的，保护的或包范围，甚至调用者不属于这些范围。但编译器不允许使用普通的代码该字段，因为仅适用于反射。

8.2访问私有方法

想要访问私有方法需要调用Class.getDeclaredMethod(String name,Class[] parameterTypes) 或Class.getDeclaredMethods() 方法. Class.getMethod(String name, Class[]parameterTypes) 和 Class.getMethods() 方法仅返回public方法。下面是一个简单的示例，类有一个私有方法，代码通过反射来访问这个私有方法:

public class PrivateObject {

        private String privateString = null;

        public PrivateObject(String privateString) {

           this.privateString = privateString;

        }

        private String getPrivateString(){

           return this.privateString;

        }

}

PrivateObject privateObject = new PrivateObject("The Private Value");

Method privateStringMethod = PrivateObject.class.getDeclaredMethod("getPrivateString", null);

privateStringMethod.setAccessible(true);

String returnValue = (String)privateStringMethod.invoke(privateObject, null);

System.out.println("returnValue = " + returnValue);

代码示例输出" returnValue = The Private Value ",即代码示例最开始创建的PrivateObject实例调用的私有方法 getPrivateString()的返回值。

注意PrivateObject.class.getDeclaredMethod("privateString")方法的使用。这个方法仅仅返回特定类声明的方法，而不包括任何父类中声明的方法。

注意粗体代码.通过调用Method.setAcessible（true）方法关闭了特定Method实例的访问检查。现在通过反射可以访问它，即使它是私有的，保护的或包范围，甚至调用者不属于这些范围。但编译器不允许使用普通的代码访问该方法，因为仅适用于反射。

9. Array

在Java反射中使用数组有时候有点棘手，特别是如果你想获得某种类型的数组的Class对象，如int[]等。本节将讨论如何通过Java反射创建数组和Class对象。以下是本章涵盖的主题：

(1) java.lang.reflect.Array

(2) 创建数组

(3) 访问数组

(4) 获取数组的Class对象

(5) 获取数组的组件类型

9.1 java.lang.reflect.Array

通过Java反射机制使用数组是由thejava.lang.reflect.Array类完成的。不要把这个类和Java集合框架中的java.util.Arrays类相混淆，java.util.Arrays类包含数组排序，将它们转换为集合等公共方法。

9.2 创建数组

通过Java反射机制创建数组是由java.lang.reflect.Array类来完成的，如下:

int[] intArray = (int[]) Array.newInstance(int.class, 3);

这行代码创建了一个int数组。Array.newInstance()方法的第一个参数告诉我们数组中的元素类型。第二个参数声明了数组需要为多少个元素分配空间。

9.3 访问数组

使用Java反射机制可以访问数组的元素。这是通过 Array.get(...) 和 Array.set(...) 方法实现的，如下:

int[] intArray = (int[]) Array.newInstance(int.class, 3);

Array.set(intArray, 0, 123);

Array.set(intArray, 1, 456);

Array.set(intArray, 2, 789);

System.out.println("intArray[0] = " + Array.get(intArray, 0));

System.out.println("intArray[1] = " + Array.get(intArray, 1));

System.out.println("intArray[2] = " + Array.get(intArray, 2));

这段代码输出:

intArray[0] = 123

intArray[1] = 456

intArray[2] = 789

9.4 获取数组的Class对象

获取数组的Class对象可以使用无反射的代码，如下:

Class stringArrayClass = String[].class;

使用 Class.forName()方法并不易懂。例如，你可以像下面这样获取int数组的Class对象:

Class intArray = Class.forName("[I");

字母 I在JVM中代表一个。左边的 [ 表示它是一个int数组的class。这对其它的基本类型也有效。

对于对象，你需要使用一个稍微不同的记号:

Class stringArrayClass = Class.forName("[Ljava.lang.String;");

注意到左边的” [L”和右边的”  ; ”之间的类名。它代表对象数组的给定类型。

另外一个需要注意的是你不能够使用Class.forName()方法获取基本类型的Class对象。下面两个例子都会抛出ClassNotFoundException异常:

Class intClass1 = Class.forName("I");

Class intClass2 = Class.forName("int");

可以像下面这样获取基本数据类型和对象的Class名:

public Class getClass(String className){

       if("int" .equals(className)) return int .class;

       if("long".equals(className)) return long.class;

       ...

       return Class.forName(className);

}

一旦你获得某个类型的Class对象，有一个简单的方法来获得该类型的数组的Class对象。解决方案是创建所需类型的空数组并从这个空数组获取Class对象，如下：

Class theClass = getClass(theClassName);

Class stringArrayClass = Array.newInstance(theClass, 0).getClass();

这提供了一个单一的、统一的方法来访问任何类型的数组的Class对象。

要确保 Class对象是一个数组,可以使用Class.isArray()方法来校验:

Class stringArrayClass = Array.newInstance(String.class, 0).getClass();

System.out.println("is array: " + stringArrayClass.isArray());

9.5 获取数组的组件类型

一旦获取到某个数组的Class对象可以使用 Class.getComponentType()方法来获取它的组件类型。组件类型就是数组中元素的类型。例如，int数组的组件类型是 int.class Class对象.String[]数组的组件类型是 java.lang.String Class对象。

下面是获取数组的组件类型的示例:

String[] strings = new String[3];

Class stringArrayClass = strings.getClass();

Class stringArrayComponentType = stringArrayClass.getComponentType();

System.out.println(stringArrayComponentType);

输出 "class java.lang.String"即为String数组的组件类型.

10.        注解

使用Java反射你可以在运行时访问Java类中的注解.下面是本章涵盖的主题:

(1)什么是Java注解？

(2)类注解

(3)方法注解

(4)参数注解

(5)字段注解

10.1 什么是Java注解?

注解是Java5的一个新功能。注解是一种可以在Java代码中插入的注释或元数据。这些注解可以在编译时由预编译工具进行处理，也可以在运行时通过Java反射机制来处理。下面是一个类注解的示例:

@MyAnnotation(name="someName",  value = "Hello World")

public class TheClass {

}

TheClass类的上面有  @MyAnnotation 注解.注解像接口那样定义。下面是MyAnnotation注解 的定义:

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

public @interface MyAnnotation {

        public String name();

        public String value();

}

在interface前面的”@”标志它是一个注解。一旦你定义了那个注解你就可以在代码中使用它，就像上面的例子那样。

在注解中定义的两个指令@Retention(RetentionPolicy.RUNTIME)和 @Target(ElementType.TYPE)表明注解是如何使用的

@Retention(RetentionPolicy.RUNTIME)表明在运行时可以使用反射来访问这个注解。如果没有设置这个指令，在运行时这个注解将不会被保存，因此通过反射访问不到。

@Target(ElementType.TYPE) 表明注解仅能用于类、接口（包括注释类型）或枚举声明等类型上。你也可以指定 METHOD 或FIELD,或者@Target什么都不指定，这样它可以用在任何程序元素上。

10.2 类注解

可以在运行时获取类、方法或字段的注解。下面是获取类注解的示例：

Class aClass = TheClass.class;

Annotation[] annotations = aClass.getAnnotations();

for(Annotation annotation : annotations){

        if(annotation instanceof MyAnnotation){

            MyAnnotation myAnnotation = (MyAnnotation) annotation;

            System.out.println("name: " + myAnnotation.name());

            System.out.println("value: " + myAnnotation.value());

         }

}

也可以获取指定的类注解，如下：

Class aClass = TheClass.class;

Annotation annotation = aClass.getAnnotation(MyAnnotation.class);

if(annotation instanceof MyAnnotation){

         MyAnnotation myAnnotation = (MyAnnotation) annotation;

         System.out.println("name: " + myAnnotation.name());

         System.out.println("value: " + myAnnotation.value());

}

10.3 方法注解

下面是方法注解的示例:

public class TheClass {

         @MyAnnotation(name="someName",  value = "Hello World")

          public void doSomething(){}

}

获取方法的所有注解，如下：

Method method = ... //obtain method object

Annotation[] annotations = method.getDeclaredAnnotations();

for(Annotation annotation : annotations){

         if(annotation instanceof MyAnnotation){

             MyAnnotation myAnnotation = (MyAnnotation) annotation;

             System.out.println("name: " + myAnnotation.name());

             System.out.println("value: " + myAnnotation.value());

         }

}

获取方法的特定注解:

Method method = ... // obtain method object

Annotation annotation = method.getAnnotation(MyAnnotation.class);

if(annotation instanceof MyAnnotation){

       MyAnnotation myAnnotation = (MyAnnotation) annotation;

       System.out.println("name: " + myAnnotation.name());

        System.out.println("value: " + myAnnotation.value());

}

10.4 参数注解

也可以给方法声明的参数添加注解，如下：

public class TheClass {

         public static void doSomethingElse(

            @MyAnnotation(name="aName", value="aValue") String parameter){

         }

}

从Method对象获取参数注解：

Method method = ... //obtain method object

Annotation[][] parameterAnnotations = method.getParameterAnnotations();

Class[] parameterTypes = method.getParameterTypes();

int i=0;

for(Annotation[] annotations : parameterAnnotations){

         Class parameterType = parameterTypes[i++];

         for(Annotation annotation : annotations){

            if(annotation instanceof MyAnnotation){

                MyAnnotation myAnnotation = (MyAnnotation) annotation;

                System.out.println("param: " + parameterType.getName());

                System.out.println("name : " + myAnnotation.name());

                System.out.println("value: " + myAnnotation.value());

            }

         }

}

注意 Method.getParameterAnnotations() 方法返回的是二维的Annotation数组,每个方法参数都有一个一维的Annotation数组。

10.5 字段注解

下面是字段注解示例:

public class TheClass {

         @MyAnnotation(name="someName",  value = "Hello World")

         public String myField = null;

}

获取字段的所有注解，如下：

Field field = ... //obtain field object

Annotation[] annotations = field.getDeclaredAnnotations();

for(Annotation annotation : annotations){

         if(annotation instanceof MyAnnotation){

            MyAnnotation myAnnotation = (MyAnnotation) annotation;

            System.out.println("name: " + myAnnotation.name());

            System.out.println("value: " + myAnnotation.value());

         }

}

获取指定字段的注解，如下：

Field field = ... // obtain method object

Annotation annotation = field.getAnnotation(MyAnnotation.class);

if(annotation instanceof MyAnnotation){

         MyAnnotation myAnnotation = (MyAnnotation) annotation;

         System.out.println("name: " + myAnnotation.name());

         System.out.println("value: " + myAnnotation.value());

}                                                                                      

11.     泛型

经常在文章和论坛里读到说所有Java泛型信息在编译的时候被擦除了所以在运行时访问不到任何泛型信息。这并不完全正确。在极少数的情况下，在运行时是可以访问泛型信息的。这些情况实际上涵盖一些我们需要的Java泛型信息。本章将解释这些情况。下面是本章涵盖的主题：

(1) 泛型反射的经验法则

(2) 泛型方法的返回值类型

(3) 泛型方法的参数类型

(4) 泛型字段类型

11.1 泛型反射的经验法则

使用Java的泛型通常分为两种不同的情况：

(1)声明一个可参数化的类/接口。

(2)使用参数化的类。

当写一个类或接口时，可以指定它应该是可参数化的。就像java.util.List接口那样，可以参数化java.util.List来创建一个String列表而不是创建Object列表。

java.util.List在运行时会检查参数化的类型，但是没有办法知道参数化的是什么类型。这是因为在相同的应用程序中类型可以被参数化为所有的类型。但是，当你检查方法或字段所声明使用的参数化类型，你可以在运行时看到可参数化的类型被参数化为什么类型。总之，你不能在运行时看到类型本身被参数化为什么类型，但你可以在使用和参数化它的字段和方法中看到它。

11.2 泛型方法的返回值类型

如果你获取到一个java.lang.reflect.Method 对象，可以获取它的返回值类型信息。下面是一个示例，一个类有一个有参数化返回值类型的方法：

public class MyClass {

        protected List<String> stringList = ...;

        public List<String> getStringList(){

           return this.stringList;

        }

}

在这个类中可以获取 getStringList()方法的泛型返回值类型。换句话说，可以探测到getStringList()返回的是List<String> 而不仅是一个 List。如下：

Method method = MyClass.class.getMethod("getStringList", null);

Type returnType = method.getGenericReturnType();

if(returnType instanceof ParameterizedType){

       ParameterizedType type = (ParameterizedType) returnType;

       Type[] typeArguments = type.getActualTypeArguments();

       for(Type typeArgument : typeArguments){

           Class typeArgClass = (Class) typeArgument;

           System.out.println("typeArgClass = " + typeArgClass);

       }

}

代码输出 "typeArgClass = class java.lang.String"。

Type[]数组 typeArguments包含一项 -一个代表类java.lang.String的 Class实例 。 Class实现了 Type接口。

11.3 泛型方法的参数类型

通过Java反射可以在运行时访问参数类型的泛型类型。下面的示例中，类有一个使用参数化的List作为参数的方法：

public class MyClass {

         protected List<String> stringList = ...;

          public void setStringList(List<String> list){

             this.stringList = list;

          }

}

可以访问方法参数的泛型参数类型，如下：

Method method = Myclass.class.getMethod("setStringList", List.class);

Type[] genericParameterTypes = method.getGenericParameterTypes();

for(Type genericParameterType : genericParameterTypes){

        if(genericParameterType instanceof ParameterizedType){

           ParameterizedType aType = (ParameterizedType) genericParameterType;

           Type[] parameterArgTypes = aType.getActualTypeArguments();

           for(Type parameterArgType : parameterArgTypes){

               Class parameterArgClass = (Class) parameterArgType;

               System.out.println("parameterArgClass = " + parameterArgClass);

           }

         }

}

代码输出"parameterArgType= class java.lang.String"。

 Type[]数组 parameterArgTypes包含一项 -一个代表类java.lang.String的 Class实例 。 Class实现了 Type接口。

11.4 泛型字段类型

可以访问public字段的泛型类型。字段即类的成员变量-静态的或实例变量。下面是一个例子，类有一个实例变量stringList.

public class MyClass {

         public List<String> stringList = ...;

}

Field field = MyClass.class.getField("stringList");

Type genericFieldType = field.getGenericType();  

if(genericFieldType instanceof ParameterizedType){

         ParameterizedType aType = (ParameterizedType) genericFieldType;

         Type[] fieldArgTypes = aType.getActualTypeArguments();

         for(Type fieldArgType : fieldArgTypes){

            Class fieldArgClass = (Class) fieldArgType;

            System.out.println("fieldArgClass = " + fieldArgClass);

          }

}

代码将输出"fieldArgClass = class java.lang.String"。

 Type数组fieldArgTypes包含一项 – 一个代表类java.lang.String的 Class实例 。 Class实现了 Type接口。

反射的缺点。第一个是性能问题。用于字段和方法接入时反射要远 慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况 下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问 题。反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方 ——记录其在目标类中的使用。

反射原理（为什么我们可以再程序运行时获取到类的信息所有信息并且创建对象调用方法）？

java虚拟机的方法区:   

java虚拟机有一个运行时数据区，这个数据区又被分为方法区，堆区和栈区，我们这里需要了解的主要是方法区。

方法区的主要作用是存储被装载的类的类型信息，当java虚拟机装载某个类型的时候，需要类装载器定位相应的class文件，然后将其读入到java虚拟机中，紧接着虚拟机提取class中的类型信息，将这些信息存储到方法区中。

这些信息主要包括:   1、这个类型的全限定名   2、这个类型的直接超类的全限定名   3、这个类型是类类型还是接口类型   4、这个类型的访问修饰符   5、任何直接超接口的全限定名的有序列表   6、该类型的常量池   7、字段信息   8、方法信息   9、除了常量以外的所有类变量   10、一个到class类对象的引用   等等(读者可以参考《深入java虚拟机》这本书的叙述)   

Class类:   Class类是一个非常重要的java基础类，每当装载一个新的类型的时候，java虚拟机都会在java堆中创建一个对应于新类型的Class实例，该实例就代表此类型，通过该Class实例我们就可以访问该类型的基本信息。上面说到在方法区中会存储某个被装载类的类型信息，我们就可以通过Class实例来访问这些信息。

总结：因为在jvm 加载类的时候动态的创建了一个Class对象，通过这个对象，又可以获得类相关的属性方法构造器等其他任何信息对应的独享，所以这个类的所有信息都可以被或得到。得到了这些对象就可以动态创建类对应的实例，并且调用方法了，就实现了反射。

反射的使用场景有哪些？

1）.Java的反射机制在做基础框架的时候非常有用，有一句话这么说来着：反射机制是很多Java框架的基石。而一般应用层面很少用，不过这种东西，现在很多开源框架基本都已经给你封装好了，自己基本用不着写。典型的除了hibernate之外，还有spring也用到很多反射机制。经典的就是在xml文件或者properties里面写好了配置，然后在Java类里面解析xml或properties里面的内容，得到一个字符串，然后用反射机制，根据这个字符串获得某个类的Class实例，这样就可以动态配置一些东西，不用每一次都要在代码里面去new或者做其他的事情，以后要改的话直接改配置文件，代码维护起来就很方便了，同时有时候要适应某些需求，Java类里面不一定能直接调用另外的方法，这时候也可以通过反射机制来实现。
总的来说，自己写的很少，具体什么时候要用那要看需求，反射机制无非就是根据一个String来得到你要的实体对象，然后调用它原来的东西。但是如果是要自己写框架的话，那就会用得比较多了。

2）当你做一个软件可以安装插件的功能，你连插件的类型名称都不知道，你怎么实例化这个对象呢？因为程序是支持插件的（第三方的），在开发的时候并不知道 。所以无法在代码中 New出来 ，但反射可以，通过反射，动态加载程序集，然后读出类，检查标记之后再实例化对象，就可以获得正确的类实例。

3）在编码阶段不知道那个类名,要在运行期从配置文件读取类名, 这时候就没有办法硬编码new ClassName(),而必须用到反射才能创建这个对象.反射的目的就是为了扩展未知的应用。比如你写了一个程序，这个程序定义了一些接口，只要实现了这些接口的dll都可以作为插件来插入到这个程序中。那么怎么实现呢？就可以通过反射来实现。就是把dll加载进内存，然后通过反射的方式来调用dll中的方法

4）spring 中用了好多注解，判断哪些类上有注解的逻辑 就是通过反射实现的。

5   Proxy.newProxyInstance() 动态代理 的原理就是 反射，

这个代码内部会根据传进去的类加载器和接口 创建出 实现类，并在实现类的方法内部调用传进去的参数 handler 的invoke 方法，

handler 的invoke 方法内部 是自己实现的，不过也是调用 method.invoke(proxyinstance,args)方法。

所以等于两个地方用到了反射，现根据接口生成了代理，然后handler 处理器invoke 方法也是使用了 反射的方法。