[Java] 反射机制 02

反射

1. 反射机制即指java可以在运行期间通过Class的Class Class.forName(String)方法动态地加载一个类
2. 继而可以通过获得的该类对应的的Class对象的Object newInstance()方法实例化出该类的对象
3. 然后可以通过Method[]  getMethods() 和Field[] getFields()等方法了解类的内部结构
4. 最后就可以根据方法的内部结构决定该方法应该怎么样去调用，从而动态地去调用类的方法m.invoke(Object,Object... args)

反射的例子：TestReflection.java

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;


public class TestRefection {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        String str = "T";
        Class c = Class.forName(str);
        p("-----------");
        Object o = c.newInstance();
        Method[] ms = c.getMethods();
        for (Method m : ms) {
            // p(m.getName());
            if (m.getName().equals("mm")) {
                m.invoke(o, null);
            }
            if (m.getName().equals("m1")) {
                m.invoke(o, 1, 2);
                for (Class paramType : m.getParameterTypes()) {
                    p(paramType.getName());
                }
            }
            if (m.getName().equals("getS")) {
                Class returnType = m.getReturnType();
                p(returnType.getName());
            }
        }
    }
    public static void p(Object o) {
        System.out.println(o);
    }
}
class T {
    static {
        System.out.println("T loaded!");
    }
    int i;
    String s;
    public T() {
        System.out.println("T constructed!");
    }
    public void mm() {
        System.out.println("mm invoked!");
    }
    public void m1(int i, int j) {
        this.i = i + j;
    }
    public String getS() {
        return s;
    }
}

输出 ：

T loaded!
-----------
T constructed!
mm invoked!
int
int
java.lang.String

反射机制的好处在于可以使程序的可扩展性变的非常好；例如可以在配置文件里配置类名，然后在程序中动态的加载加载配置文件中指定的类并调用其方法，调方法之前还可以先检查这个人有没有这个权限，在Spring Hibernate transaction的处理以及面向切面的编程AOP中都大量用到了反射机制