Java反射

反射是什么

在计算机科学中，反射是指计算机程序在运行时（Run time）可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说，反射就是程序在运行的时候能够“观察”并且修改自己的行为。

反射是Java编程语言的一个特性，它允许运行时的Java程序检测自身状态，并且修改程序的内部属性。

一个反射的典型使用就是IDE，我们在编写代码的时候，编译工具会自动把该对象能够使用的所有的方法和属性全部列出来，供我们选择使用。这就是利用了Java的反射原理，是对我们创建对象的探知、自审。

一个简单例子

为了看看反射如何工作，我们来看看下面的例子：

import java.lang.reflect.Method;

public class DumpMethods {

    public static void main(String args[]) {
        try {
            Class c = Class.forName(args[0]);
            Method m[] = c.getDeclaredMethods();
            for (int i = 0; i < m.length; i++) {
                System.out.println(m[i].toString());
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

命令行下编译后执行：

javac DumpMethods.java

java DumpMethods java.util.Stack

输出如下：

oyty-mbp:src oyty$ java DumpMethods java.util.Stack
public java.lang.Object java.util.Stack.push(java.lang.Object)
public synchronized java.lang.Object java.util.Stack.pop()
public synchronized java.lang.Object java.util.Stack.peek()
public boolean java.util.Stack.empty()
public synchronized int java.util.Stack.search(java.lang.Object)

上面打印的就是类java.util.Stack的所有方法名，并且包含完整的参数和返回值类型。

这个程序使用class.forName加载了指定的类，然后调用getDeclaredMethods获取在类中定义的所有方法。java.lang.reflect.Method是表示单一类方法的类。

使用反射

反射的相关类，例如Method，存在于包java.lang.reflect中。要使用这些类，你必须遵循下面的三个步骤：

第一步，获取你要操作的类的java.lang.Class对象

获取Class对象的一种方式：

// 获得String类的Class对象
Class c = Class.forName("java.lang.String");

另一种方式：

Class c = int.class;
or
Class c = Integer.TYPE;

第二步，调用相关方法

比如，你可以调用getDeclaredMethods方法来获取类里面所有定义的方法。

第三步

一旦拿到第二步获取到的信息，就可以使用反射的API去操作这些信息。例如：

Class c = Class.forName("java.lang.String");    
Method m[] = c.getDeclaredMethods();    
System.out.println(m[0].toString());

上面的程序序列将会打印在String里面定义的第一个方法。

模拟instanceof操作符

一旦我们拿到了Class的信息，通常下一步我们会做一些基本的问题，比如用Class.isInstance方法来模拟instanceof操作符。

class A {}

public class InstanceA {
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("A");
            boolean b1 = cls.isInstance(new Integer(37));
            System.out.println(b1);
            boolean b2 = cls.isInstance(new A());
            System.out.println(b2);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

在上面的例子中，类A的Class对象被创建，然后一些类的实例对象被用来检测他们是否是A的实例。Integer(37)显然不是，new A()是的。

找出Class的方法

反射的一个最基本和最有价值的使用就是找出在一个类中定义了哪些方法，要这样做可以使用下面的代码：

import java.lang.reflect.*;

public class Method1 {
    private int f1(Object p, int x) throws NullPointerException {
        if (p == null)
            throw new NullPointerException();
        return x;
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("Method1");

            Method methlist[] = cls.getDeclaredMethods();
            for (int i = 0; i < methlist.length; i++) {
                Method m = methlist[i];
                System.out.println("name= " + m.getName());
                System.out.println("decl class = " + m.getDeclaringClass());
                Class pvec[] = m.getParameterTypes();
                for (int j = 0; j < pvec.length; j++) {
                    System.out.println("param #" + j + " " + pvec[j]);
                }
                Class evec[] = m.getExceptionTypes();
                for (int j = 0; j < evec.length; j++) {
                    System.out.println("exc #" + j + " " + evec[j]);
                }
                System.out.println("return type = " + m.getReturnType());
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

代码输出为：

name= main
decl class = class Method1
param #0 class [Ljava.lang.String;
return type = void
-----
name= f1
decl class = class Method1
param #0 class java.lang.Object
param #1 int
exc #0 class java.lang.NullPointerException
return type = int
-----

上面的程序，首先获取到了method1的Class对象，然后调用getDeclaredMethods方法获取类中定义的Method对象数组，这些方法包含public、protected，package和private方法。如果你使用getMethods方法而不是getDeclaredMethods方法，你也将会获得继承的方法信息。需要注意的getMethods返回的是包含父类属性中修饰符为public的方法。
一旦获取到了方法数组，就很容易得到每个方法的参数类型，异常类型和返回类型。

获取类的构造方法

反射还可以用来获取一个类的构造方法信息：

import java.lang.reflect.*;

public class Constructor1 {

    public Constructor1() {
    }

    protected Constructor1(int i, double d) {
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("Constructor1");

            Constructor ctorlist[] = cls.getDeclaredConstructors();
            for (int i = 0; i < ctorlist.length; i++) {
                Constructor ct = ctorlist[i];
                System.out.println("name = " + ct.getName());
                System.out.println("decl class = " + ct.getDeclaringClass());

                Class pvec[] = ct.getParameterTypes();
                for (int j = 0; j < pvec.length; j++) {
                    System.out.println("param #" + j + " " + pvec[j]);
                }

                Class evec[] = ct.getExceptionTypes();
                for (int j = 0; j < evec.length; j++) {
                    System.out.println("exc #" + j + " " + evec[j]);
                }
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

输出为：

name = Constructor1
decl class = class Constructor1
-----
name = Constructor1
decl class = class Constructor1
param #0 int
param #1 double
-----

这里没有获取返回类型信息，因为构造方法并没有返回类型。

获取类的属性

我们还可以获得类中定义的属性：

import java.lang.reflect.*;

public class Field1 {
    private double d;
    public static final int i = 37;
    String s = "testing";

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("Field1");

            Field fieldlist[] = cls.getDeclaredFields();
            for (int i = 0; i < fieldlist.length; i++) {
                Field fld = fieldlist[i];
                System.out.println("name = " + fld.getName());
                System.out.println("decl class = " + fld.getDeclaringClass());
                System.out.println("type = " + fld.getType());

                int mod = fld.getModifiers();
                System.out.println("modifiers = " + Modifier.toString(mod));
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

输出为：

name = d
decl class = class Field1
type = double
modifiers = private
-----
name = i
decl class = class Field1
type = int
modifiers = public static final
-----
name = s
decl class = class Field1
type = class java.lang.String
modifiers = 
-----

这里使用了Modifier，这是表示属性的修饰符的类。
我们可以使用getDeclaredFields获取类中定义的属性，也可以使用getFields额外获取父类中定义的属性。需要注意的后者返回的是包含父类属性中修饰符为public的属性。

通过方法名调用方法

目前为止，上面的一些例子都是展示如何获取类的信息，还有一些其它的使用反射的方式，比如调用一个特定的方法。
看看下面的代码：

import java.lang.reflect.*;

public class Method2 {

    public int add(int a, int b) {
        return a + b;
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("Method2");
            Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Method meth = cls.getMethod("add", partypes);
            Method2 methobj = new Method2();
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj = meth.invoke(methobj, arglist);
            Integer retval = (Integer) retobj;
            System.out.println(retval.intValue());
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

试想一下，一个程序想要去调用add方法，但是直到程序执行的时候才知道这个方法，所以在程序执行的时候，方法的名字才被指定。
getMethod用来在Class中寻找有两个Integer类型参数和方法名为add的方法。一旦这个方法被找到，并且赋值给Method对象后，就可以在合适的参数下调用。

创建新的对象

方法的调用和构造方法的调用是不一样的，因为你调用一个构造方法，实际上是创建了一个新的对象。准确来说，创建一个新的对象包含了内存分配和对象构建。
通过构造方法创建对象：

import java.lang.reflect.*;

public class Constructor2 {
    public Constructor2() {
    }

    public Constructor2(int a, int b) {
        System.out.println("a = " + a + " b = " + b);
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("Constructor2");
            Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Constructor ct = cls.getConstructor(partypes);
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj = ct.newInstance(arglist);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

上面程序找到了一个有特定参数类型的构造方法，执行调用后，创建了对象的一个新的实例。这种方式创建对象的价值在于它是完全动态的，实在程序执行时寻找和执行构造方法，而不是在编译时。

修改属性值

反射的另一个用法是修改对象属性的值，这也是反射的一个动态特性。在程序执行时通过属性名寻找属性并且修改它的值。

import java.lang.reflect.*;

public class Field2 {
    public double d;

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("Field2");
            Field fld = cls.getField("d");
            Field2 f2obj = new Field2();
            System.out.println("d = " + f2obj.d);
            fld.setDouble(f2obj, 12.34);
            System.out.println("d = " + f2obj.d);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

在上面例子中，属性d的值被修改成了12.34。

使用数组

反射的最后一个用法是创建和使用数组。数组是Java语言中的一个特殊类型，一个数组引用可以赋值给一个Object引用。

import java.lang.reflect.*;

public class Array1 {
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("java.lang.String");
            Object arr = Array.newInstance(cls, 10);
            Array.set(arr, 5, "this is a test");
            String s = (String) Array.get(arr, 5);
            System.out.println(s);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

上面程序创建了长度为10的String类型的数组，然后将数组中索引为5的值赋值为一个字符串。
更复杂点的看看下面：

import java.lang.reflect.*;

public class Array2 {
    public static void main(String args[]) {
        int dims[] = new int[]{5, 10, 15};
        Object arr = Array.newInstance(Integer.TYPE, dims);
        Object arrobj = Array.get(arr, 3);
        System.out.println(arrobj);
        Class cls = arrobj.getClass().getComponentType();
        System.out.println(cls);
        arrobj = Array.get(arrobj, 5);
        Array.setInt(arrobj, 10, 37);
        int arrcast[][][] = (int[][][]) arr;
        System.out.println(arrcast[3][5][10]);
    }
}

上面的程序创建了一个5x10x15的三维int类型数组。然后将位置[3][5][10]设置为37，一个多维数组实际上就是数组的数组，所以第一次Array.get后得到的是一个10x15的二维数组。

总结

Java的反射支持动态获取类的信息，数据结构，并且在程序执行时动态修改。这个特性非常强大。

参考：
http://www.oracle.com/technetwork/articles/java/javareflection-1536171.html