设计模式：代理模式

1. 定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。
2. 举例：AOP实现，拦截器，中介，黄牛，媒婆
3. 代理模式可分成两种：1.静态代理；2.动态代理；
4. 共同点：代理角色（Proxy类）得行为由被代理角色（XiaoMing）来做最终决定，所以代理类通常会持有被代理角色对象引用，以便代理角色完成工作之前或之后能找到代理对象，能够通知被代理对象。附图一张。。
5. 不同点：静态代理：在代理之前，被代理类得一切是已知得。（可以代理类和被代理类都实现同一个接口来实现，被代理类组合进代理类，通过newInstance或者构造方法来赋值）这里就不符代码了。
6. 动态代理：直接贴代码

/**
 * 接口
 */
public interface Person {

    String findJob();

    String doHomeWork();

    String doHouseWork();

    String makeMoney();
}

* @create 2018-12-11 17:11
 * @desc 被代理类：小明同学
 **/
public class XiaoMing implements Person{
    @Override
    public String findJob() {
        System.out.println("工作要求：月薪过万");
        return "工作要求：月薪过万";
    }

    @Override
    public String doHomeWork() {
        System.out.println("作业要求：干的快");
        return "作业要求：干的快";
    }

    @Override
    public String doHouseWork() {
        System.out.println("家务要求：干的贼干净");
        return "家务要求：干的贼干净";
    }

    @Override
    public String makeMoney() {
        System.out.println("挣钱要求：够吃饭");
        return "挣钱要求：够吃饭";
    }
}

    

 * @create 2018-12-11 17:33
 * @desc 动态代理测试类
 **/
public class DynamicProxyTest {

    public static void main(String[] args) {
        Person person = (Person) new DynamicProxy().newInstance(new XiaoMing());
        person.findJob();
        person.doHomeWork();
    }
}

执行结果：

至此我们做到了不需要关心被代理类的方法，只需要拿到他的interface便可以对其进行代理；

打印出来的$Proxy0类：

public final class $Proxy0 extends Proxy implements Person {
    private static Method m1;
    private static Method m5;
    private static Method m2;
    private static Method m4;
    private static Method m6;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void findLove() throws  {
        try {
            super.h.invoke(this, m5, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void zufangzi() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void buy() throws  {
        try {
            super.h.invoke(this, m6, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void findJob() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m5 = Class.forName("com.gupaoedu.vip.pattern.proxy.staticed.Person").getMethod("findLove");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m4 = Class.forName("com.gupaoedu.vip.pattern.proxy.staticed.Person").getMethod("zufangzi");
            m6 = Class.forName("com.gupaoedu.vip.pattern.proxy.staticed.Person").getMethod("buy");
            m3 = Class.forName("com.gupaoedu.vip.pattern.proxy.staticed.Person").getMethod("findJob");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

 

另外一种动态代理是cglib：他的好处是被代理类不再需要实现接口啦！！

public class ZhangSan {

    public void findLove(){
        System.out.println("肤白貌美大象腿");
    }

}

 

public class CglibMeipo implements MethodInterceptor{

    public Object getInstance(Class<?> clazz) throws  Exception{

        Enhancer enhancer = new Enhancer();
        //要把哪个设置为即将生成的新类父类
        enhancer.setSuperclass(clazz);

        enhancer.setCallback(this);

        return  enhancer.create();

    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //业务的增强

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

        methodProxy.invokeSuper(o,objects);

        System.out.println("如果合适的话，就准备办事");
        return null;
    }
}

 

public class CglibTest {

    public static void main(String[] args) {

        try {
            ZhangSan obj = (ZhangSan)new CglibMeipo().getInstance(ZhangSan.class);
            obj.findLove();
            System.out.println("--------------------------------");
           // System.out.println(obj.getClass());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}