代理模式（Proxy Pattern）是程序设计中的一种设计模式。
代理者是指一个类别可以作为其它东西的接口。代理者可以作任何东西的接口：网络连接、存储器中的大对象、文件或其它昂贵或无法复制的资源。

指为其他对象提供一种代理，以控制对这个对象的访问。代理对象在客服端和目标对象之间起到中介作用，代理模式属于结构型设计模式。

应用场景：
租房中介、售票黄牛、婚介、经纪人、快递、事务代理、非侵入式日志监听等

使用的目的：
1.保护目标对象
2.增强目标对象

代理模式分为：静态代理和动态代理

静态代理

代码实现

public interface Person {
    public void findObject();
}

public class Son implements Person{
    public void findObject(){
        //我没有时间
        //工作忙
        System.out.println("儿子要求：高富美");
    }
}

public class Father {
    private Son son;
    //没办法扩展
    public Father(Son son){
        this.son = son;
    }
    //目标对象的引用给拿到
    public void findLove(){
        System.out.println("父母物色对象");
        this.son.findLove();
        System.out.println("双方同意交往，确立关系");
    }
}

//测试
public static void main(String[] args) {
    //只能帮儿子找对象
    //不能帮表妹、不能帮陌生人
    Father father = new Father(new Son());
    father.findLove();
}

//结果
//父母物色对象
//儿子要求：高富美
//双方同意交往，确立关系

缺点：代理单一，无法很好的进行扩展

动态代理

动态代理和静态对比基本思路是一致的，只不过动态代理功能更加强大，随着业务的扩展适应性更强

JDK的动态代理的代码实现

实现了jdk的InvocationHandler接口，这里要实现他的接口invoke处理

public class JDKMP implements InvocationHandler{
    //被代理的对象，把引用给保存下来
    private Object target;
    public Object getInstance(Object target) throws Exception{
        this.target = target;
        Class<?> clazz = target.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object obj = method.invoke(this.target,args);
        after();
        return obj;
    }

    private void before(){
        System.out.println("我是介绍人：我要给你找对象，现在已经拿到你的需求");
        System.out.println("开始物色");
    }

     private void after(){
        System.out.println("如果合适的话，就开始交往");
     }
}

创建被代理的类

public class Customer implements Person{
    public void findLove(){
        System.out.println("皮肤好，有钱");
        System.out.println("身高 175cm");
        System.out.println("胸大，腰细，屁股翘");
     }
}

测试类

public static void main(String[] args) {
    try {
        Person obj = (Person)new JDKMeipo().getInstance(new Customer());
        obj.findLove();
    } catch (Exception e) {
        e.printStackTrace();
    }
}
//结果
/**
*我是介绍人：我要给你找对象，现在已经拿到你的需求
*开始物色
*皮肤好，有钱
*身高 175cm
*胸大，腰细，屁股翘
*如果合适的话，就开始交往
*/

结论：
jdk proxy是采用字节码重组，重新生成新的对象来代替原始的对象以达到动态代理的目的

JDK Proxy生成对象的步骤：
1、拿到被代理对象的引用，并且获取到它的所有的接口，反射获取。
2、JDK Proxy 类重新生成一个新的类、同时新的类要实现被代理类所有实现的所有的接口。
3、动态生成 Java 代码，把新加的业务逻辑方法由一定的逻辑代码去调用（在代码中体现）。
4、编译新生成的 Java 代码.class。
5、再重新加载到 JVM 中运行。

JDK 中有一个规范，在 ClassPath 下只要是$开头的 class文件一般都是自动生成的。

CGlib动态代理方式实现

CGLib同样需要实现一个接口(MethodInterceptor)，实现intercept这个方法

public class CglibMP implements MethodInterceptor{
    public Object getInstance(Class<?> clazz) throws Exception{
        Enhancer enhancer = new Enhancer();
        //要把哪个设置为即将生成的新类父类
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws
Throwable {
        //业务的增强
        before();
        Object obj = methodProxy.invokeSuper(o,objects);
        after();
        return obj;
    }

    private void before(){
        System.out.println("我是媒婆：我要给你找对象，现在已经拿到你的需求");
        System.out.println("开始物色");
    }

    private void after(){
        System.out.println("如果合适的话，就准备办事");
    }
}

public class Customer {
    public void findObject(){
        System.out.println("肤白貌美胸大腰细大长腿");
    }
}

public class CglibTest {
    public static void main(String[] args) {
        try {
            Customer obj = (Customer)new CglibMP().getInstance(Customer.class);
            obj.findObject();
        } catch (Exception e) {
             e.printStackTrace();
        }
    }
}

细节：CGLib代理的目标对象不需要实现任何接口，它是通过动态继承目标对象实现动态代理的

CGLib和JDK动态代理的对比

1.JDK 动态代理是实现了被代理对象的接口，CGLib 是继承了被代理对象。

2.JDK 和 CGLib 都是在运行期生成字节码，JDK 是直接写 Class 字节码，CGLib 使用 ASM框架写 Class 字节码，Cglib 代理实现更复杂，生成代理类比 JDK 效率低。

3.JDK 调用代理方法，是通过反射机制调用，CGLib 是通过 FastClass 机制直接调用方法，CGLib 执行效率更高。

静态代理和动态代理的本质区别

1、静态代理只能通过手动完成代理操作，如果被代理类增加新的方法，代理类需要同步新增，违背开闭原则。

2、动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则。

3、若动态代理要对目标类的增强逻辑扩展，结合策略模式，只需要新增策略类便可完成，无需修改代理类的代码。

代理模式的优点：

1、代理模式能将代理对象与真实被调用的目标对象分离。
2、一定程度上降低了系统的耦合度，扩展性好。
3、可以起到保护目标对象的作用。
4、可以对目标对象的功能增强。

缺点：
1、代理模式会造成系统设计中类的数量增加。
2、在客户端和目标对象增加一个代理对象，会造成请求处理速度变慢。
3、增加了系统的复杂度。