反射机制 —— 将类中的所有成员反射成对于的类。

以“com.test.Person”类为例

	转换对应的类	获取方法	说明
类	Class	Class mClass = Person.class;	通过类名直接获取
		Class mClass = new Person().getClass();	通过对象获取
		Class mClass  = Class.forName("com.test.Person");	通过全类名获取
		Class superClass = mClass.getSuperclass();	获取父类
成员变量	Field	Field[] fields = clazz.getDeclaredFields();	获取全部成员变量的Field
		Field field1 = mClass.getDeclaredField("name");	获指定变量的 Field
		Object val = field1.get(new Person());	获取指定变量的 Field 的值
		field1.set(new Person(), "张三");	设置指定变量的 Field 的值
构造方法	Constructor	Class<Person> clazz = (Class<Person>) Class.forName(className);	获取指定类的 Class
		Constructor<Person>[] constructors = (Constructor<Person>[]) Class.forName(className).getConstructors();	获取全部构造方法的 Constructor
		Constructor<Person> constructor = clazz.getConstructor(String.class, int.class);	获取指定的构造方法的 Constructor （参数代表构造方法的参数类型）
成员方法	Method	Method[] methods = mClass.getMethods();	获取部分成员方法（不能获取private方法）
		Method[] methods = clazz.getDeclaredMethods();	获取全部成员方法
		Method method1 = clazz.getDeclaredMethod("setName", String.class); Method method2 = clazz.getDeclaredMethod("setName", String.class, int.class);	获取指定方法（参1：方法名，参2之后：方法参数类型）

 

 

1 package steffen.reflex; 2 public class Persion { 3     public String name="李四"; 4     private int age = 10; 5     public Persion(){} 6     public Persion(String name, int age){ 7         this.name = name; 8         this.age = age; 9     }10     public String getName(){
   return name;}11     private int getAge(){
   return age;}12 }

 

1 /** 2  * Class 类对象 3  * @throws ClassNotFoundException 4  */ 5  private void classTest() throws ClassNotFoundException{ 6     Class classString = String.class; 7     Class classString2 = new String().getClass(); 8     Class classString3 = Class.forName("java.lang.String"); // 不支持内部类 9         10     System.out.println("1.1 classString="+classString);11     System.out.println("1.2 classString2="+classString2);12     System.out.println("1.3 classString3="+classString3);13         14     // 总结： Class对象有系统自动创建，且只创建一次。15  }

// 输出结果1.1 classString=class java.lang.String1.2 classString2=class java.lang.String1.3 classString3=class java.lang.String

 

1 constructorTest("steffen.reflex.Persion"); 2  3 /** 4  * constructor 构造方法对象 5  * @param className 6  * @throws ClassNotFoundException 7  */ 8 private void constructorTest(String className) throws ClassNotFoundException { 9     Class
      clazz = Class.forName(className);10     Constructor
     [] constructors = (Constructor
     [])clazz.getConstructors();11     12     // 1.获取全部构造方法13     System.out.println("2.1 获取"+className+"全部构造方法：");14     for (Constructor
      element : constructors) {15         System.out.println(element+"; ");16     }17     System.out.println();18     19     // 2.获取某个构造方法20     Constructor
      constructors2;21     try {22         constructors2 = clazz.getConstructor(String.class, int.class);23         System.out.println("2.2 获取某个特定的构造方法："+constructors2);24     } catch (NoSuchMethodException e) {25         e.printStackTrace();26     } catch (SecurityException e) {27         e.printStackTrace();28     }29 }

// 输出结果2.1 获取steffen.reflex.Persion全部构造方法：public steffen.reflex.Persion(); public steffen.reflex.Persion(java.lang.String,int); 2.2 获取某个特定的构造方法：public steffen.reflex.Persion(java.lang.String,int)

 

1 fieldTest("steffen.reflex.Persion"); 2  3 /** 4  * Field 变量对象 5  * @param className 6  * @throws ClassNotFoundException 7  */ 8 private void fieldTest(String className) throws ClassNotFoundException{ 9     Class
      clazz = Class.forName(className);10     11     // 获取所以变量12     Field[] arrField = clazz.getDeclaredFields();13     System.out.println("3.1 显示"+className+"所有变量：");14     for (Field field : arrField) {15         System.out.println(field+"; ");16     }17     System.out.println();18     19     // 获取某个特定的变量20     try {21         Persion mPersion = new Persion();22         Field fieldName = clazz.getDeclaredField("name");23         System.out.println("3.2 获取名为name的变量对象："+fieldName);24         // 设置该对象的值：25         try {26             fieldName.set(mPersion, "张三");27         } catch (IllegalArgumentException e) {28             e.printStackTrace();29         } catch (IllegalAccessException e) {30             e.printStackTrace();31         }32         // 获取该变量的值33         try {34             Object obj = fieldName.get(mPersion);35             System.out.println("3.3 名为name的值为："+obj);36         } catch (IllegalArgumentException e1) {37             e1.printStackTrace();38         } catch (IllegalAccessException e1) {39             e1.printStackTrace();40         }41     } catch (NoSuchFieldException e) {42         e.printStackTrace();43     } catch (SecurityException e) {44         e.printStackTrace();45     }46 }

// 输出结果3.1 显示steffen.reflex.Persion所有变量：public java.lang.String steffen.reflex.Persion.name; private int steffen.reflex.Persion.age; 3.2 获取名为name的变量对象：public java.lang.String steffen.reflex.Persion.name3.3 名为name的值为：张三

 

1 methodTest("steffen.reflex.Persion"); 2  3 /** 4  * Method 方法对象 5  * @param className 6  * @throws ClassNotFoundException 7  */ 8 private void methodTest(String className) throws ClassNotFoundException { 9     Class
      clazz = Class.forName(className);10     11     // 5.1 获取类所有的方法12     Method[] arrMethod = clazz.getDeclaredMethods();13     System.out.println("4.1 获取类的所有方法：");14     for (Method method : arrMethod) {15         System.out.println(method+"; ");16     }17     System.out.println();18     // 5.2 获取类的公开方法19     Method[] arrMethod2 = clazz.getMethods();20     System.out.print("4.2 获取类的所有Public方法：");21     for (Method method : arrMethod2) {22         System.out.println(method+"; ");23     }24     System.out.println();25     26     try {27         // 获取指定方法28         Method methodGetAge = clazz.getDeclaredMethod("getAge");29         System.out.println("4.3 获取指定方法："+methodGetAge);30     } catch (NoSuchMethodException e) {31         e.printStackTrace();32     } catch (SecurityException e) {33         e.printStackTrace();34     }35 }

// 输出结果4.1 获取类的所有方法：public java.lang.String steffen.reflex.Persion.getName(); private int steffen.reflex.Persion.getAge(); 4.2 获取类的所有Public方法：public java.lang.String steffen.reflex.Persion.getName(); public final void java.lang.Object.wait() throws java.lang.InterruptedException; public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException; public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException; public boolean java.lang.Object.equals(java.lang.Object); public java.lang.String java.lang.Object.toString(); public native int java.lang.Object.hashCode(); public final native java.lang.Class java.lang.Object.getClass(); public final native void java.lang.Object.notify(); public final native void java.lang.Object.notifyAll(); 4.3 获取指定方法：private int steffen.reflex.Persion.getAge()

 

 

适用场景及利弊

一、反射的适用场景是什么？

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

总的来说，自己写的很少，具体什么时候要用那要看需求，反射机制无非就是根据一个 String 来得到你要的实体对象，然后调用它原来的东西。但是如果是要自己写框架的话，那就会用得比较多了。

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

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

二、程序员在自己的业务开发中应该尽量的远离反射

反射：在流行的库如 Spring 和 Hibernate 中，反射自然有其用武之地。不过内省业务代码在很多时候都不是一件好事，原因有很多，一般情况下建议不要使用反射。

首先是代码可读性与工具支持。打开熟悉的 IDE，寻找你的 Java 代码的内部依赖，很容易吧。现在，使用反射来替换掉你的代码然后再试一下，结果如何呢？如果通过反射来修改已经封装好的对象状态，那么结果将会变得更加不可控。比如下面这段代码：

Class
      clazz = Class.forName("steffen.reflex.Persion");Field[] arrField = clazz.getDeclaredFields();

如果这样做就无法得到编译期的安全保证。就像上面这个示例一样，你会发现如果 getDeclaredField() 方法调用的参数输错了，那么只有在运行期才能发现。要知道的是，寻找运行期 Bug 的难度要远远超过编译期的 Bug。

最后还要谈谈代价问题。JIT 对反射的优化程度是不同的，有些优化时间会更长一些，而有些甚至是无法应用优化。因此，有时反射的性能损失可以达到几个数量级的差别。不过在典型的业务应用中，你可能不会注意到这个代价。

总结一下，我觉得在业务代码中唯一合理(直接)使用反射的场景是通过 AOP。除此之外，你最好远离反射这一特性。

三、性能分析

反射机制是一种程序自我分析的能力。用于获取一个类的类变量，构造函数，方法，修饰符。

优点：运行期类型的判断，动态类加载，动态代理使用反射。

缺点：性能是一个问题，反射相当于一系列解释操作，通知 jvm 要做的事情，性能比直接的 java 代码要慢很多。