Java 知识点 —— 反射

一、什么是反射

java 运行时，识别对象和类的信息的传统方式是 RTTI，它要求我们再编译阶段就确定所以对象的信息，比如，如何去构造它，参数是什么...而反射机制则是在运行阶段去确认这些信息。

二、反射的实现

简单的例子，假设我们有一个类 ReflectModel:

package SSMTest;
import static MyTools.PrintTools.*;

public class ReflectModel {

    private String name;
    
    public ReflectModel() {}
    
    public ReflectModel(String name) {
        this.name = name;
    }
    public void HelloWorld() {
        println("Hello World");
    }
    public void NameSay() {
        println(name + "say Hello World");
    }
}

一般情况下，我们创建该类的实例是在编译阶段就确认好的：

package SSMTest;

public class ReflectImpl {
    public static void main(String args[]) {
        ReflectModel reflectModel1 = new ReflectModel();
        ReflectModel reflectModel2 = new ReflectModel("Li ");
        reflectModel1.HelloWorld();
        reflectModel2.NameSay();
        
    }
}
/*output
Hello World
Li say Hello World
*/

但是，假如我希望能够在运行的时候，再去决定如何创建这个类，该如何实现？这里可以使用 java 的反射机制：

package SSMTest;

import java.lang.reflect.InvocationTargetException;

public class ReflectImpl1 {

    public static void main(String[] args) {
        ReflectModel model1 = null,model2 = null;
        try {
            model1 = (ReflectModel)Class.forName("SSMTest.ReflectModel").newInstance();
            model1.HelloWorld();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            model2 = (ReflectModel)Class.forName("SSMTest.ReflectModel").getConstructor(
                    String.class).newInstance("Li");
            model2.NameSay();
        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
                | NoSuchMethodException | SecurityException | ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

}
/*output
Hello World
Lisay Hello World
*/

Class.fornName() 方法可以帮我们根据类的全名去找到这个类的加载器，然后通过加载器的 newInstance() 方法创建一个对象，如果是带参数的构造器，则使用加载器的 getConstructor({参数类型}.class)找到对应构造函数的加载器，然后再用 newInstance() 方法创建一个对象。

如此一来我们便实现了在运行过程中去确定类的实现方式。那么，既然类的初始化可以在运行时实现，类的方法是否也能在运行时去找到它并且进行调用？以下是实现方式：

package SSMTest;

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

public class ReflectImpl2 {

    public static void main(String[] args) {
        ReflectModel model1 = null;
        Object returnObj = null;
        try {
            model1 = (ReflectModel)Class.forName("SSMTest.ReflectModel").newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            Method method = ReflectModel.class.getMethod("HelloWorld");
            returnObj = method.invoke(model1);
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

}
/*output
Hello World*/

如果是带参数的方法，例如参数是 String，则将 18 行修改为：

Method method = ReflectModel.class.getMethod("HelloWorld"，String.class);

同样第 19 行修改为

returnObj = method.invoke(model1,"args");