概述

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

原理

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。

动态代理使用场合

调试
远程方法调用

动态代理相比于静态代理的优点

抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

静态代理

静态代理的缺点

① 代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。
② 每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。

Class MyThread implements Runnable{} //相当于被代理类
Class Thread implements Runnable{} //相当于代理类
main(){
    MyThread t = new MyThread();
    Thread thread = new Thread(t);
    thread.start();//启动线程；调用线程的run()
}

Java动态代理

java动态代理机制中有两个重要的类和接口InvocationHandler（接口）和Proxy（类），这一个类Proxy和接口InvocationHandler是我们实现动态代理的核心；

InvocationHandler接口

InvocationHandler接口是proxy代理实例的调用处理程序实现的一个接口，每一个proxy代理实例都有一个关联的调用处理程序；在代理对象调用方法时，方法调用被编码分派到调用处理程序的invoke方法。
每一个动态代理类的调用处理程序都必须实现InvocationHandler接口，并且每个代理类的实例都关联到了实现该接口的动态代理类调用处理程序中，当我们通过动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现InvocationHandler接口类的invoke方法来调用，看如下invoke方法：

Proxy类

Proxy类就是用来创建一个代理对象的类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类，我们最常用的是newProxyInstance方法。
提供用于创建动态代理类和动态代理对象的静态方法

第一个参数：obj.getClass().getClassLoader()，使用obj对象的classloader对象来加载我们的代理对象
第二个参数：obj.getClass().getInterfaces()，这里为代理类提供的接口是真实对象实现的接口，这样代理对象就能像真实对象一样调用接口中的所有方法
第三个参数：handler，我们将代理对象关联到上面的InvocationHandler(代理类的调用处理程序)对象上

动态代理的实现

需要解决的两个主要问题：

问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。

通过Proxy.newProxyInstance()实现

问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。

通过InvocationHandler接口的实现类及其方法invoke()

  public class ProxyModelTest {
    public static void main(String[] args) {
        //创建一个被代理类的对象
        ReallyStar reallyStar = new ReallyStar();
        //创建一个代理类的对象
        StarStandard proxyInstance =(StarStandard) ProxyFatory.getProxyInstance(reallyStar);
        //通过代理类调用被代理类的对象
        proxyInstance.sing();
        proxyInstance.dance();
    }
------------------------------------------------------------------------------------------------------------------------
}
//被代理接口
interface StarStandard {
    void sing();
    void dance();
}
//被代理类
class ReallyStar implements StarStandard {
    @Override
    public void sing() {
        System.out.println("我会唱歌");
    }
    @Override
    public void dance() {
        System.out.println("我会跳舞");
    }
}
//代理工厂
class ProxyFatory{
    //该方法通过一个 被代理类对象 获取一个代理对象-----定义为object对象是为了操作不同的代理类对象
    public static Object getProxyInstance(Object o){
       //创建代理对象的调用处理程序，将被代理的对象传入代理对象的调用处理的构造函数中，
       //最终代理对象的调用处理程序会调用被代理对象的同名方法
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler(o);
       //通过Proxy类的newProxyInstance方法创建代理对象
       Object proxyInstance = Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(), myInvocationHandler);
        return proxyInstance;//用于返回代理实例
    }
}
//定义一个代理类的调用处理程序
class MyInvocationHandler implements InvocationHandler{
    private Object obj;////代理类中的真实对象
    public MyInvocationHandler(Object obj) {
        this.obj = obj;
    }
    @Override           //代理类对象     调用的代理类的方法   方法形参
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //通过Method对象调用obj中的method方法<反射>
        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        Object returnValue = method.invoke(obj, args);
        //会返回代理类调用方法的返回值
        return returnValue;
    }
}

动态代理与AOP（Aspect Orient Programming)

使用Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理
这种动态代理在AOP中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异： AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理