动态代理实战
动态代理它可以直接给某一个目标(被代理 对象)对象(实现了某个或者某些接口)生成一个代理对象，而不需要代理类存在。
动态代理与代理模式原理是一样的，只是它没有具体的代理类，直接通过反射生成了一个代理对象。
jdk中的动态代理
1、Java.lang.reflect.Proxy类可以直接生成一个代理对象
Proxy.newProxyInstance方法参数介绍
ClassLoader：类加载器
它是用来加载器的，把.class文件加载到内存，形成Class对象！
Class[] interfaces：指定要实现的接口们
InvocationHandler：代理对象的所有方法(个别不执行，getClass())都会调用InvocationHandler的invoke()方法。
2、InvocationHandler方法参数介绍
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
这个invoke()方法在什么时候被调用！在调用代理对象所实现接口中的方法时
Object proxy：当前对象，即代理对象！在调用谁的方法！
Method method：当前被调用的方法（目标方法）
Object[] args：实参！
示例一：
Customer类为需要打官司的顾客，Lawyer为律师类，Lawyer类需要代理Customer打官司。
定义代理类与目标类共同的接口：
interface Law {
//定义一个打官司的接口，需要实现打官司
void law();
}
被代理类：某个客户需要打官司
class Customer implements Law {
@Override
public void law() {
System.out.println("上法庭陈述事实");
}
}
创建实现动态代理的MyHandler类，实现InvocationHandler接口和invoke方法。
/**
* 实现动态代理的核心接口，动态代理本质采用的java反射机制实现
*/
class MyHandler implements InvocationHandler {
private Customer customer;
public MyHandler(Customer customer) {
this.customer = customer;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("搜集证据");
Object obj = method.invoke(customer, args); //使用反射调用customer中的method方法
System.out.println("打赢官司");
return obj;
}
}
执行测试：
public static void main(String[] args) {
//代理目标对象
Customer customer = new Customer();
//代理回调类
MyHandler myHandler = new MyHandler(customer);
//生成代理对象Proxy通过调用newProxyInstance方法生成代理对象，传入该类的classLoader，实现接口，InvocationHandler
Law proxy = (Law) Proxy.newProxyInstance(Customer.class.getClassLoader(), customer.getClass().getInterfaces(), myHandler);
proxy.law();
}
调用结果：
示例二：
定义代理类与目标类共同的接口：
public interface HelloInterface {
void sayHello();
}
被代理类：
class Hello implements HelloInterface {
@Override
public void sayHello() {
System.out.println("这里是被代理类Hello");
}
}
创建实现动态代理的ProxyHandler类，实现InvocationHandler接口和invoke方法。
class ProxyHandler implements InvocationHandler {
private Object object;
//需要传入Object类型，任意类型
public ProxyHandler(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//invoke中使用反射调用传入的被代理对象的方法
System.out.println("before invoke" + method.getName());
method.invoke(object, args);
System.out.println("after invoke" + method.getName());
return null;
}
}
执行测试：
public static void main(String[] args) {
HelloInterface hello = new Hello(); //创建需要被代理的Hello类对象
//此时，不再创建具体的代理对象，而是用Proxy.newProxyInstance利用反射生成代理对象
InvocationHandler invocationHandler = new ProxyHandler(hello);
//通过Proxy类的静态方法newProxyInstance返回一个接口的代理实例（注，这里需要强转）。针对不同的代理类，传入相应的代理程序控制器InvocationHandler。
//newProxyInstance需传入三个参数：分别传入被代理对象的classloader、interface，和创建的invocationHandler，
HelloInterface proxyHello = (HelloInterface) Proxy.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), invocationHandler);
proxyHello.sayHello(); //通过调用代理接口的方法，调用到了invocationHandler的invoke方法，从而调用到了被代理对象的方法
}
调用结果：
动态代理比静态代理优秀的方法在于，可以动态地代理各个被代理类，那么此时新的代理类就来了。
创建新的代理类Bye:
public interface ByeInterface {
void sayBye();
}
class Bye implements ByeInterface {
@Override
public void sayBye() {
System.out.println("这里是被代理类Bye");
}
}
重新执行：
public static void main(String[] args) {
HelloInterface hello = new Hello(); //创建需要被代理的Hello类对象
ByeInterface bye = new Bye();
//此时，不再创建具体的代理对象，而是用Proxy.newProxyInstance利用反射生成代理对象
InvocationHandler invocationHandler = new ProxyHandler(hello);
InvocationHandler byeHandler = new ProxyHandler(bye);
//通过Proxy类的静态方法newProxyInstance返回一个接口的代理实例（注，这里需要强转）。针对不同的代理类，传入相应的代理程序控制器InvocationHandler。
//newProxyInstance需传入三个参数：分别传入被代理对象的classloader、interface，和创建的invocationHandler，
HelloInterface proxyHello = (HelloInterface) Proxy.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), invocationHandler);
proxyHello.sayHello(); //通过调用代理接口的方法，调用到了invocationHandler的invoke方法，从而调用到了被代理对象的方法
ByeInterface proxyBye = (ByeInterface) Proxy.newProxyInstance(bye.getClass().getClassLoader(), bye.getClass().getInterfaces(), byeHandler);
proxyBye.sayBye();
}
执行结果：
动态代理具体步骤：
通过实现 InvocationHandler 接口创建自己的调用处理器；
通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。
