设计模式之-代理模式(proxy)

代理模式(proxy)

代理模式是为对象提供一种代理控制对这个对象的访问,从结构上来说和装饰器模式类似,但是Proxy是控制,更像是一种对功能的限制,而装饰器模式是增加职责,Spring的Proxy模式在AOP中有体现,比如JdkDynamicAopProxy和Cglib2AopProxy

代理模式属于结构型模式,执行者、被代理人
对于被代理人来说，这件事情是一定要做的，但是我
自己又不想做或者没有时间做。
对于代理人而言，需要获取到被代理的人个人资料，
只是参与整个过程的某个或几个环节。

代码实现

首先我们来看正常的JDK动态代理
首先我们来看以下场景,把一个人需要的干的事定义成一个接口

public interface Person {

    public void findLove();

    public void zufangzi();

    public void buy();

    public void findJob();

    //......
}

这时候小明需要相亲,找工作,租房子,那就要找一个相亲机构和中介来代理小明找,小明只需要告诉条件就可以了,

public class XiaoMing implements Person{

    public void findLove(){
        System.out.println("高富帅");
        System.out.println("身高180cm");
        System.out.println("胸大，6块腹肌");

    }

    @Override
    public void zufangzi() {
        System.out.println("租房子");
    }

    @Override
    public void buy() {
        System.out.println("买东西");
    }

    @Override
    public void findJob() {
        System.out.println("月薪20K-50k");
        System.out.println("找工作");
    }

    public void  hhh(){

    }
}

接下来我们需要找一个代理人去帮我们找工作,比如说58同城,我们创建一个代理类实现InvocationHandler这个接口(JDK动态代理实现InvocationHandler这个接口就可以了),使用Proxy生成一个代理对象

public class JDK58 implements InvocationHandler{
    //被代理的对象，把引用给保存下来
    private Person target;

    public Object getInstance(Person target) throws Exception{
        this.target = target;

       Class<?> clazz = target.getClass();
        //用来生成一个新的对象（字节码重组来实现）
        return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("我是58：我要给你找工作，现在已经拿到你的简历");
        System.out.println("开始投递");

        method.invoke(this.target,args);

        System.out.println("安排面试");

        return  null;
    }
}

public class JDKProxyTest {

    public static void main(String[] args) {

        try {
            Person obj = (Person)new JDK58().getInstance(new XiaoMing());
            System.out.println(obj.getClass());
            obj.findJob();

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

            //JDK中有个规范，只要要是$开头的一般都是自动生成的

            //通过反编译工具可以查看源代码
            byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{Person.class});
            FileOutputStream os = new FileOutputStream("E://$Proxy0.class");
            os.write(bytes);
            os.close();





        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

接下里测试
结果如下
class com.sun.proxy.$Proxy0
我是58：我要给你找工作，现在已经拿到你的简历
开始投递
月薪20K-50k
找工作
安排面试

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 m3;
    private static Method m6;
    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})).booleanValue();
        } 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, m3, (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, m6, (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)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

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

我们通过反编译工具编译可以看到代理类是默认继承了Proxy类的,
每个方法都是调用了super.h.invoke(this, m6, (Object[])null);
而这个方法最终执行就是通过你传入的参数和方法名在JDK58的invoke中来找到最终实现类执行的方法

当面试官问你为什么JDK动态代理需要接口时
回答:java是单继承的,而代理的时候默认继承了Proxy类,只能使用接口来生成代理类,可以看到上面的的实现类中我加了一个接口中没有的方法
,生成的代理类中也没有这个方法;

手动实现Proxy待更新