Roadmap
1. 基本概念
1.1 什么是反射
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。
1.2 反射的作用
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的方法
生成动态代理
反向工程 .class -> .java前提是在运行时，不是编译时，也就是在运行前并不知道调用哪一个类，通过反射就可以做到这些
1.3 反射中的类
java.lang.Class
java.lang.reflect.Constructor
java.lang.reflect.Field
java.lang.reflect.Method
java.lang.reflect.Modifier
2 反射的使用
2.1 反射机制获取类
public class MyReflection {
// 属性方法省略
public static void main(String[] arg) throws ClassNotFoundException {
//第一种方式：
Class c1 = Class.forName("refelection.MyReflection");
//第二种方式：每个类都有 .class
Class c2 = MyReflection.class;
//第三种方式：
Class c3 = new MyReflection().getClass();
｝
｝
2.2 获取所有属性
public static void main(String[] arg) throws ClassNotFoundException {
Class c1 = Class.forName("refelection.MyReflection");
Class c2 = MyReflection.class;
Class c3 = new MyReflection().getClass();
Field[] fs1 = c1.getDeclaredFields();
Field[] fs2 = c2.getFields();
Method[] method1 = c1.getDeclaredMethods();
Method[] method2 = c2.getMethods();
Constructor[] cts1 = c1.getDeclaredConstructors();
Constructor[] cts12 =c2.getDeclaredConstructors();
for(Field field:fs1){
System.out.println("** get declaredFields **");
System.out.println(Modifier.toString(field.getModifiers()));
System.out.println( field.getType().getSimpleName());
System.out.println( field.getName());
}
for(Field field:fs2){
System.out.println("** get getFields **");
System.out.println(Modifier.toString(field.getModifiers()));
System.out.println( field.getType().getSimpleName());
System.out.println( field.getName());
}
for(Method method:method1){
System.out.println("** get getDeclaredMethods **");
System.out.println(Modifier.toString(method.getModifiers()));
System.out.println( method.getName());
}
for(Method method:method2){
System.out.println("** get getMethods **");
System.out.println(Modifier.toString(method.getModifiers()));
System.out.println( method.getName());
}
for(Constructor constructor:cts1){
System.out.println("** get getDeclaredConstructors **");
System.out.println(Modifier.toString(constructor.getModifiers()));
System.out.println( constructor.getName());
}
for(Constructor constructor:cts12){
System.out.println("** get getConstructors **");
System.out.println(Modifier.toString(constructor.getModifiers()));
System.out.println( constructor.getName());
}
}
* getFields()与getDeclaredFields()区别:getFields()只能访问类中声明为公有的字段,私有的字段它无法访问，能访问从其它类继承来的公有方法.getDeclaredFields()能访问类中所有的字段,与public,private,protect无关，不能访问从其它类继承来的方法
* getMethods()与getDeclaredMethods()区别:getMethods()只能访问类中声明为公有的方法,私有的方法它无法访问,能访问从其它类继承来的公有方法.getDeclaredFields()能访问类中所有的字段,与public,private,protect无关,不能访问从其它类继承来的方法
* getConstructors()与getDeclaredConstructors()区别:getConstructors()只能访问类中声明为public的构造函数.getDeclaredConstructors()能访问类中所有的构造函数,与public,private,protect无关
2.3 获取指定属性
获取指定属性与获取全部属性的方法类似 并且一一对应，方法名没有S以外，返回的对象是具体对象而不是数组了。
//获取类
Class c = Class.forName("User");
//获取id属性
Field idF = c.getDeclaredField("id");
2.4 打破封装
类方法有一些是私有的，反射机制提供了setAccessiable(true)方法，打破封装性，这样可以通过反射解析一些私有方法，如读取，赋值等。 显然这是一个不安全的操作。
//获取类
Class c = Class.forName("User");
//获取id属性
Field idF = c.getDeclaredField("id");
//实例化这个类赋给o
Object o = c.newInstance();
//打破封装
idF.setAccessible(true); //使用反射机制可以打破封装性，导致了java对象的属性不安全。
idF.set(o, "110"); //set
另外，在框架满天飞的时代下面，有的时候在运行程序的时候 会遇到 java.lang.IllegalAccessException:
多数情况下是在用反射机制下，访问了私有属性的缘故
3 动态代理
3.1 InvocationHandler
每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法：
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
proxy: 指代我们所代理的那个真实对象
method: 指代的是我们所要调用真实对象的某个方法的Method对象
args: 指代的是调用真实对象某个方法时接受的参数
3.2 Proxy
Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
这个方法的作用就是得到一个动态的代理对象，其接收三个参数，
loader:一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces:一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
h:一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
3.3 开始动态代理
3.3.1 构建真实对象
public interface Subject {
void call(String content);
}
public class RealSubject implements Subject{
public void call(String content){
System.out.println(content);
}
}
3.3.2 构建动态代理类
public class DynamicProxy implements InvocationHandler {
private Object subject;
// 构造方法，给我们要代理的真实对象赋初值
public DynamicProxy(Object subject)
{
this.subject = subject;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在代理真实对象前我们可以添加一些自己的操作
System.out.println("before call");
System.out.println("Method:" + method);
// 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
method.invoke(subject, args);
// 在代理真实对象后我们也可以添加一些自己的操作
System.out.println("after call");
return null;
}
}
3.3.3 客户端调用
public static void main(String[] arg){
// 我们要代理的真实对象
Subject realSubject = new RealSubject();
// 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
InvocationHandler handler = new DynamicProxy(realSubject);
/*
* 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
* 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
* 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
* 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
*/
Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject
.getClass().getInterfaces(), handler);
System.out.println(subject.getClass().getName());
subject.call("test");
}
输出：
com.sun.proxy.$Proxy0
before call
Method:public abstract void refelection.proxy.Subject.call(java.lang.String)
test
after call
