Java反射机制概念及使用

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

以“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之后：方法参数类型）

 

package steffen.reflex;
public class Persion {
    public String name="李四";
    private int age = 10;
    public Persion(){}
    public Persion(String name, int age){
        this.name = name;
        this.age = age;
    }
    public String getName(){return name;}
    private int getAge(){return age;}
}

/**
 * Class 类对象
 * @throws ClassNotFoundException
 */
 private void classTest() throws ClassNotFoundException{
    Class classString = String.class;
    Class classString2 = new String().getClass();
    Class classString3 = Class.forName("java.lang.String"); // 不支持内部类
        
    System.out.println("1.1 classString="+classString);
    System.out.println("1.2 classString2="+classString2);
    System.out.println("1.3 classString3="+classString3);
        
    // 总结： Class对象有系统自动创建，且只创建一次。
 }

// 输出结果
1.1 classString=class java.lang.String
1.2 classString2=class java.lang.String
1.3 classString3=class java.lang.String

constructorTest("steffen.reflex.Persion");

/**
 * constructor 构造方法对象
 * @param className
 * @throws ClassNotFoundException
 */
private void constructorTest(String className) throws ClassNotFoundException {
    Class<?> clazz = Class.forName(className);
    Constructor<?>[] constructors = (Constructor<?>[])clazz.getConstructors();
    
    // 1.获取全部构造方法
    System.out.println("2.1 获取"+className+"全部构造方法：");
    for (Constructor<?> element : constructors) {
        System.out.println(element+"; ");
    }
    System.out.println();
    
    // 2.获取某个构造方法
    Constructor<?> constructors2;
    try {
        constructors2 = clazz.getConstructor(String.class, int.class);
        System.out.println("2.2 获取某个特定的构造方法："+constructors2);
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    }
}

// 输出结果
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)

fieldTest("steffen.reflex.Persion");

/**
 * Field 变量对象
 * @param className
 * @throws ClassNotFoundException
 */
private void fieldTest(String className) throws ClassNotFoundException{
    Class<?> clazz = Class.forName(className);
    
    // 获取所以变量
    Field[] arrField = clazz.getDeclaredFields();
    System.out.println("3.1 显示"+className+"所有变量：");
    for (Field field : arrField) {
        System.out.println(field+"; ");
    }
    System.out.println();
    
    // 获取某个特定的变量
    try {
        Persion mPersion = new Persion();
        Field fieldName = clazz.getDeclaredField("name");
        System.out.println("3.2 获取名为name的变量对象："+fieldName);
        // 设置该对象的值：
        try {
            fieldName.set(mPersion, "张三");
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        // 获取该变量的值
        try {
            Object obj = fieldName.get(mPersion);
            System.out.println("3.3 名为name的值为："+obj);
        } catch (IllegalArgumentException e1) {
            e1.printStackTrace();
        } catch (IllegalAccessException e1) {
            e1.printStackTrace();
        }
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    }
}

// 输出结果
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.name
3.3 名为name的值为：张三

methodTest("steffen.reflex.Persion");

/**
 * Method 方法对象
 * @param className
 * @throws ClassNotFoundException
 */
private void methodTest(String className) throws ClassNotFoundException {
    Class<?> clazz = Class.forName(className);
    
    // 5.1 获取类所有的方法
    Method[] arrMethod = clazz.getDeclaredMethods();
    System.out.println("4.1 获取类的所有方法：");
    for (Method method : arrMethod) {
        System.out.println(method+"; ");
    }
    System.out.println();
    // 5.2 获取类的公开方法
    Method[] arrMethod2 = clazz.getMethods();
    System.out.print("4.2 获取类的所有Public方法：");
    for (Method method : arrMethod2) {
        System.out.println(method+"; ");
    }
    System.out.println();
    
    try {
        // 获取指定方法
        Method methodGetAge = clazz.getDeclaredMethod("getAge");
        System.out.println("4.3 获取指定方法："+methodGetAge);
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    }
}

// 输出结果
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 代码要慢很多。