Java中的反射机制Reflection

反射机制是java的一个非常重要的机制，一些著名的应用框架都使用了此机制，如struts、spring、hibernate、android app界面等等。

java.lang.Class它是java语法的一个基础类，用于描述一个class对象。在文件系统中，class以文件的形式存在。在运行的JVM中，*.class文件被加载到内存中成为一个对象，该对象的类型就是java.lang.Class。

什么是反射？

在运行状态中，对于任意一个类，都能够获取到这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性(包括私有的方法和属性)，这种动态获取信息以及动态调用对象的方法的功能就称为java语言的反射机制。也就是说，虽然我们获取不到该类的源代码，但是通过该类的.class文件能反射(Reflect)出这些信息。

通俗点讲，通过反射，该类对我们来说是完全透明的，想要获取任何东西都可以。

想要使用反射机制，就必须要先获取到该类的字节码文件对象 .class，java.lang.Class类表示 .class 字节码文件对象。通过字节码文件对象，就能够通过该类中的方法获取到我们想要的所有信息(方法、属性、类名、父类名、实现的所有接口等等)，每一个类对应着一个字节码文件也就对应着一个Class类型的对象，也就是字节码文件对象。

获取.class字节码文件对象

获取字节码文件对象的三种方式，有了字节码文件对象才能获得类中所有的信息，我们在使用反射获取信息时，也要考虑使用下面哪种方式获取字节码对象合理，视不同情况而定。

//方法一
Class clazz1 = Class.forName("my.Student");//通过Class类中的静态方法forName，直接获取到一个类的字节码文件对象，此时该类还是源文件阶段，并没有变为字节码文件。包名为 my，类名为 Student
//方法二
Class clazz2 = Student.class;  //当类被加载成.class文件时，此时Student.java类变成了Student.class，该类处于字节码阶段
//方法三
Student s=new Student();    //实例化Student对象
Class clazz3 = s.getClass();　//通过该类的实例获取该类的字节码文件对象，该类处于创建对象阶段

获取该.class字节码文件对象的详细信息

当我们得到一个.class字节码文件对象，我们可以得到以下信息：

类名 (含package路径)
函数 (名称，参数类型，返回值）
域（名称，类型）
实现的接口 (interfaces)

使用 java.lang.reflect.*下的类来实现

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.text.DateFormat.Field;
public class main
	public static void main(String[] args) throws Exception{
		Object obj=new Student();  //Student实例
		Class cls=obj.getClass();  //得到Student字节码对象
		//通过函数名和函数参数，得到函数
		String methodName="setId";           //函数名字
		Class[] par={int.class,String.class};  //函数参数
		Method m=cls.getMethod(methodName, par);   //返回函数
		//调用method
		Object[]  paramters={123,"haha"};   //传递参数
		m.invoke(obj,paramters);       //执行函数
		cls.getPackage();  //获取包信息
		String str=cls.getSimpleName();   //Student ，获得该类的名字，不包含包名
		String str2=cls.getName();       //my.Student，获得该类的名字，包含包名
		Object obj2=cls.newInstance();    //创建一个实例，要求有一个不带参数的构造函数
		int modified=cls.getModifiers();  //获取cls对象的类修饰符
		Class[] interfaces=cls.getInterfaces();  //获取实现的接口集合
		Constructor[]  con=cls.getConstructors();  //获取构造函数的集合
		Method[]  methods=cls.getMethods();  //获取函数列表
		cls.getDeclaredAnnotations();  //获取私有函数(protected和private修饰的)
		java.lang.reflect.Field[]  fields=cls.getFields();  //获取成员变量列表
		cls.getDeclaredField(str2);  //获取私有变量(protected和private修饰的)
	}
}

通过反射机制执行函数

如下，下面的代码中我们利用JAVA 的反射机制来调用计算器。我们利用了Java的反射机制把我们的代码意图都利用字符串的形式进行体现，使得原本应该是字符串的属性，变成了代码执行的逻辑。

import java.lang.reflect.InvocationTargetException;
public class main3 {
	public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, ClassNotFoundException {
	     Object runtime=Class.forName("java.lang.Runtime").getMethod("getRuntime",new Class[]{}).invoke(null); //得到Runtime.getRuntime()函数
	     Class.forName("java.lang.Runtime").getMethod("exec", String.class).invoke(runtime,"calc.exe");  //执行函数
	}
}

运行代码，可以看到，执行了 calc.exe 的命令

反射链

什么是反射链呢？

我们来查看 org.apache.commons.collections.functors.InvokerTransformer.java 的源代码，这个接口实现了反射链，可以通过Java的反射机制来执行任意命令

public class InvokerTransformer implements Transformer, Serializable {
      /*
          Input参数为要进行反射的对象，
          iMethodName,iParamTypes为调用的方法名称以及该方法的参数类型
          iArgs为对应方法的参数
          在invokeTransformer这个类的构造函数中我们可以发现，这三个参数均为可控参数
    */
    private static final long serialVersionUID = -8653385846894047688L;
    private final String iMethodName;
    private final Class[] iParamTypes;
    private final Object[] iArgs;
    public static Transformer getInstance(String methodName) {
        if (methodName == null) {
            throw new IllegalArgumentException("The method to invoke must not be null");
        }
        return new InvokerTransformer(methodName);
    }
    public static Transformer getInstance(String methodName, Class[] paramTypes, Object[] args) {
        if (methodName == null) {
            throw new IllegalArgumentException("The method to invoke must not be null");
        }
        if (((paramTypes == null) && (args != null))
            || ((paramTypes != null) && (args == null))
            || ((paramTypes != null) && (args != null) && (paramTypes.length != args.length))) {
            throw new IllegalArgumentException("The parameter types must match the arguments");
        }
        if (paramTypes == null || paramTypes.length == 0) {
            return new InvokerTransformer(methodName);
        } else {
            paramTypes = (Class[]) paramTypes.clone();
            args = (Object[]) args.clone();
            return new InvokerTransformer(methodName, paramTypes, args);
        }
    }
    private InvokerTransformer(String methodName) {
        super();
        iMethodName = methodName;
        iParamTypes = null;
        iArgs = null;
    }
    public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
        super();
        iMethodName = methodName;
        iParamTypes = paramTypes;
        iArgs = args;
    }
    public Object transform(Object input) {
        if (input == null) {
            return null;
        }
        try {
            Class cls = input.getClass();
            Method method = cls.getMethod(iMethodName, iParamTypes);
            return method.invoke(input, iArgs);
        } catch (NoSuchMethodException ex) {
            throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' does not exist");
        } catch (IllegalAccessException ex) {
            throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
        } catch (InvocationTargetException ex) {
            throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' threw an exception", ex);
        }
    }
    private void writeObject(ObjectOutputStream os) throws IOException {
        FunctorUtils.checkUnsafeSerialization(InvokerTransformer.class);
        os.defaultWriteObject();
    }
    private void readObject(ObjectInputStream is) throws ClassNotFoundException, IOException {
        FunctorUtils.checkUnsafeSerialization(InvokerTransformer.class);
        is.defaultReadObject();
    }
}

然后，我们去实现这个接口，只需要传入方法名、参数类型和参数，即可调用任意函数。在这里，我们可以看到，先用ConstantTransformer() 获取了 Runtime 类，接着通过反射调用 getRuntime 函数，再调用 getRuntime 的 exec() 函数，执行命令。依次调用关系为： Runtime --> getRuntime --> exec()

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
public class main2 {
   public static void main(String[] args) {
	 Transformer[] transformers=new Transformer[]{
		new ConstantTransformer(Runtime.class),  //获得Runtime.class字节码文件
                //通过反射，返回一个对象
		new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",new Class[0]}),
		new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,new Object[0]}),
		new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc.exe"})
		};
        //ChainedTransformer为链式的Transformer，会挨个执行我们定义Transformer
	Transformer transformedChain=new ChainedTransformer(transformers);
	Map innerMap=new HashMap();
	innerMap.put("value","value");
	Map outerMap = TransformedMap.decorate(innerMap, null, transformedChain);
	Map.Entry entry=(Entry)outerMap.entrySet().iterator().next();
	entry.setValue("test");  //修改值，触发执行
	}
}

可以看到，当Map中的Value值被修改了，触发执行了Transformer的transform()方法，通过反射链调用了Runtime.getRuntime.exec("calc.exe") 命令