场景：

作为程序员的我们，每天都在加班加点的撸代码，只能靠过年放假这几天交往一些异性对象，但是只会new 对象的我们，怎么跟对象交往呢？这是就需要一个代理对象（媒婆）先来代替我们要交往的对象和你交往，放心一般代理对象不会对要交往的对象动什么手脚，代理对象只是对交往对象的处理逻辑增强，真正要交往的对象的逻辑是不会改变的。

上代码：

有一个Girl只在乎身高的Girl

package com.chen.strategy.proxy;
//有一个Girl接口，并且有个date（float hight）方法，
public interface Girl {

    void date(float hight);
}

TeacerCang实现了接口，并有提出了自己的要求身高超过1.7就可以

package com.chen.strategy.proxy;
//TeacherCang实现了该接口并且进行逻辑处理
public class TeacherCang implements Girl {

    @Override
    public void dating(float hight) {
        System.out.println("I am Teacher Cang");
        if(hight>1.7f){
            System.out.println("Teacher Cang like it");
        }else{
            System.out.println("Bye Bye");
        }
    }
}

TeacherCang找到了王婆公司登记（WangCompany）登记，WangCompany就对目标进行一次代理

package com.chen.strategy.proxy;

import java.lang.reflect.Proxy;

public class WangCompany {

    public static Object proxy(Object targer){
   // 这个是用来生成接口的代理对象一般会有$Proxy...@...表示,里面参数分别为需要代理类的类加载器，需要代理类的接口（可能是多个），以及一个自定义实现的InvocationHandler接口的实现类（这个是代理类去增强的部分）。
        return Proxy.newProxyInstance(targer.getClass().getClassLoader(),targer.getClass().getInterfaces(),new WangInvocationHandler(targer));
    }

}

当然王婆需要有自己独特的业务来帮助TeacherCang物色（InvocationHandler.invoke(....)）合适Boy，合适的话在介绍给TeacherCang

package com.chen.strategy.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class WangInvocationHandler implements InvocationHandler {

//这里的target 就是TeacherCang
    private Object target;

    public WangInvocationHandler(Object target) {
        this.target = target;
    }

  //这个是功能增强接口的实现方法，里面的参数分别为代理类（前面生成的$Proxy..@...,需要增强的方法，方法参数）。
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        beforeDoSomething();
        Object res = method.invoke(target,args);//采用反射调用target（TeacherCang的方法date（...））
        afterDoSomething();
        return res;
    }

    public void beforeDoSomething(){
        System.out.println("这个还不错，我看行你看一下");
    }

    public void afterDoSomething(){
        System.out.println("完美，祝你们早生贵子");
    }
}

现在来了一个单身Boy身高1.8,看TeacherCang满意不？

package com.chen.strategy.proxy;

public class DateNow {

    public static void main(String[] args) {
        SingleBoy boy= new SingleBoy (1.8f);
        Girl g = new TeacherCang();
        Girl tonyCang = (Girl) WangCompany.proxy(g);
        tonyCang.dating(boy.getHight());
    }
}
//最终结果：
这个还不错，我看行你看一下
I am Teacher Cang
Teacher Cang like it
完美，祝你们早生贵子

质疑：

目前来看王婆公司的生意还是可以的，但是只是针对Girl的，如果是一个Boy来公司登记想找Girl的话是不是也可以呢?
1 有一个Boy接口，date的参数是cup

package com.chen.strategy.proxy;

public interface Boy {

    void date(String cup);

}

2 TeacherChen 实现了Boy接口，并且实现了date方法

package com.chen.strategy.proxy;

public class TeacherChen implements Boy {

    @Override
    public void dating(String cup) {
        System.out.println("Hello I am Teacher Chen");
        if(cup.equals("E")){
            System.out.println("Teacher Chen like it");
        }else{
            System.out.println("Bye Bye");
        }
    }
}

这个时候他们都通过王婆公司再来一次DataNow会怎样呢？

package com.chen.strategy.proxy;

public class PlayGame {

    public static void main(String[] args) {
        TuHao tuHao = new TuHao(1.8f);
        Girl g = new TeacherCang("E");
        Girl wangCang = (Girl) WangCompany.proxy(g);
        tonyCang.dating(tuHao.getHight());//注意这里wangCang 只是代理去相亲，代理的对象是TeacherCang。

        Boy b  = new TeacherChen();
        Boy tonyChen = (Boy) WangCompany.proxy(b);
        tonyChen.dating(((TeacherCang) g).getCup());//注意这里wangChen只是代理去相亲，代理的对象是TeacherChen。

    }
}
//最终结果
这个还不错，我看行你看一下
I am Teacher Cang
Teacher Cang like it
完美，祝你们早生贵子
这个还不错，我看行你看一下
Hello I am Teacher Chen
Teacher Chen like it
完美，祝你们早生贵子

动态代理：

字面上理解就是动态地为不同类的对象创建代理，增强功能，灵活的扩展。和静态代理不同的是，静态代理是程序员手动写好的代理类，再对器编译。程序运行前，代理类的class文件已经存在。而动态代理是通过反射机制动态创建而成的。

JDK 动态代理所需要的工具

java.lang.reflect.Proxy.newProxyInstance(...)
java.lang.reflect.InvocationHandler.invoke(....)