java反射机制示例与分析

Java反射机制通过JVM运行时动态获取类信息以及动态调用对象的方法。其实反射并不像我们想象的那么神秘，复杂。它通过java.lang.Class以及java.lang.reflect包的API实现的反射功能。我们在Spring AOP,JDBC数据库加载驱动都有用到反射机制。下面通过几段代码示例看看reflection究竟是如何工作的。

package com.me.reflection;
import java.lang.reflect.*;

public class DumpMethods {
    public static void main(String args[]) {
        try {
            Class c = Class.forName("java.lang.String"]);//1
            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);
        }
    }
}

大家对代码1处蛮眼熟吧，没错，在JDBC数据库加载驱动中用到了。这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Method是用来描述某个类中单个方法的一个类。
[color=red]总结：获得指定类的方式有(1)Class.forName("") (2).class 如int.class (3)包装类.TYPE 如：Integer.TYPE[/color]

package com.me.reflection;

import java.lang.reflect.*;

public class MethodDemo {
    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("com.me.reflection.MethodDemo");
//获得指定类的所有方法。通过getMethods()返回指定类所有公共方法
            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]);
           }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

这个程序首先取得 MethodDemo类的描述，然后调用 getDeclaredMethods 来获取一系列的 Method 对象，它们分别描述了定义在类中的每一个方法，包括 public、protected package和private方法等。如果你在程序中使用getMethods来代替getDeclaredMethods，你还能获得继承来的各个方法的信息。

package com.me.reflection;

import java.lang.reflect.*;

public class ConstructorDemo {
    public ConstructorDemo () {
    }

    protected ConstructorDemo (int i, double d) {
    }

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("com.me.reflection.ConstructorDemo");
//获得指定类的所有构造方法。通过getConstructors()返回指定类所有公共构造方法
            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]);
           }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

获取类构造器的用法与上述获取方法的用法类似。

package com.me.reflection;
import java.lang.reflect.*;

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

    public static void main(String args[]) {
        try {
            Class cls = Class.forName("com.me.reflection.FieldDemo");
            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);
        }
    }
}

这个例子和前面那个例子非常相似。例中使用了一个新东西 [color=red]Modifier，它也是一个 reflection 类，用来描述字段成员的修饰语[/color]，如“private int”。这些修饰语自身由整数描述，而且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描述 (如“static”在“final”之前)。

[color=blue]以上显示了通过reflection获得类信息的这种用法。那么如何动态创建类对象，调用方法呢[/color]

package com.me.reflection;

import java.lang.reflect.*;

public class ReflectionApp {
    public ReflectionApp(){}

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

    public int add(int a, int b) {
        return a + b;
    }
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("com.me.reflection.ReflectionApp");
   Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
//创建类对象 如果指定类只有默认构造方法，我们可通过cls.newInstance()直接生成类对象，只有Class和Constructor这两个类可以直接生成类对象         
            Constructor ct = cls.getConstructor(partypes);
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
[color=red]//注意：Class#getConstructor和Constructor#newInstance方法参数类型是一致的[/color]
            ReflectionApp ra = (ReflectionApp)ct.newInstance(arglist);
//获得指定类指定方法
            Method meth = cls.getMethod("add", partypes);
//动态调用类方法：通过invoke(指定类对象，方法参数类型列表)方法           
            Object retobj = meth.invoke(ra, arglist);
            Integer retval = (Integer) retobj;
            System.out.println(retval.intValue());
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

很多同学认为创建一个对象调用一下方法怎么写这么麻烦，但是使用这种方法可以在程序运行时动态地创建对象，动态调用方法，而不是在编译的时候创建对象，这一点非常有价值。大家可以参照Java API研究下如何改变属性值等其他功能。动态创建数组将在以后的文章写到。