【设计模式】代理模式那些事儿之静态代理和动态代理

【设计模式】代理模式那些事儿之静态代理和动态代理

前言

《雪地里的小画家》
下雪啦,下雪啦!
雪地里来了一群小画家。
小鸡画竹叶,小狗画梅花,
小鸭画枫叶,小马画月牙。
不用颜料不用笔,
几步就成一幅画。
青蛙为什么没参加?
他在洞里睡着啦。

还记得上小学时候的这篇课文吗?这是我记忆深刻的一篇语文课文,哈哈,在这里提出来让大家也回忆一下小学的故事。

这里面提到了小鸡,小狗,小马,小鸭,青蛙,他们都会在雪地里画画,我们以这些小动物为对象,来说明一些问题吧。

静态代理

这些会画画小动物我们抽象出一个 画家 Painter 接口来,让小动物实现 Painter ,完成 paint() 方法。

小画家 Painter

public interface Painter {
    void paint();
}

小狗 Puppy 画梅花

public class Puppy implements Painter {
    @Override
    public void paint() {
        System.out.println("小狗画梅花");
        //随机睡10s以内,假装这是处理业务逻辑
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

小马 Pony 画月牙

public class Pony implements Painter {
    @Override
    public void paint() {
        System.out.println("小马画月牙");
        //随机睡10s以内,假装这是处理业务逻辑
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

两个就够了,其他几个小画家就不模拟了,手动捂脸~

老师 Teacher 想要看Pony画画:

public class Teacher {
    public static void main(String[] args) {
        new Pony().paint();
    }
}

运行结果:

小马画月牙

Process finished with exit code 0

因为画的方法里有 随机睡x秒 的业务处理逻辑, Teacher 现在想知道具体睡了多少秒。

public class Pony implements Painter {
    @Override
    public void paint() {
        //加上时间记录,计算业务处理运行的时间
        long start = System.currentTimeMillis();
        System.out.println("小马画月牙");
        //随机睡10s以内,假装这是处理业务逻辑
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("paint 画画耗时:" + (end - start) + "毫秒");
    }
}

当然,小狗 Puppy 的 paint() 方法也要加这一段。

老师 Teacher 的问题又来了,他还想让画画的时候记录下日志,那么可以做如下修改:

public class Pony implements Painter {
    @Override
    public void paint() {
        //加上日志记录
        System.out.println("日志:开始作画");
        //加上时间记录,计算业务处理运行的时间
        long start = System.currentTimeMillis();
        System.out.println("小马画月牙");
        //随机睡10s以内,假装这是处理业务逻辑
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("日志:画完了");
        System.out.println("paint 画画耗时:" + (end - start) + "毫秒");
    }
}

可以看出,如果想要Pony在画画的时候添加一些诸如 记录执行时间 , 记录日志 这样的动作的时候,就要在实现paint()方法的时候添加时间、日志这些东西。

但是,这不合理呀,我Pony明明只需要处理画画的逻辑就行了啊!也简单,把时间处理、日志处理这些东西交给别人去做,可以把别人看成代理,这些代理分别持有paint()方法,在代理内部实现画画之外的事情。

代理

Teacher将来只和代理打交道,所以代理必须也“会画画”的业务,除此之外,才是代理处理特殊的业务。

so,代理可以看成是 具有额外功能的Painter ,那就也让他实现Painter接口,并且持有具体小画家(比如Pony)对象(因为代理需要会画画)。

处理时间的代理 TimeProxy。

public class TimeProxy implements Painter {

    private Pony pony;
    
    public TimeProxy(Pony pony) {
        this.pony = pony;
    }

    @Override
    public void paint() {
        long start = System.currentTimeMillis();
        //调用小马画画
        pony.paint();
        long end = System.currentTimeMillis();
        System.out.println("paint 画画耗时:" + (end - start) + "毫秒");
    }
}

这时的 Pony 开心了,只处理自己的逻辑即可,去掉时间、日志:

public class Pony implements Painter {
    @Override
    public void paint() {
        System.out.println("小马画月牙");
        //随机睡10s以内,假装这是处理业务逻辑
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

来,Teacher走一遍,让代理给我办事:

public class Teacher {
    public static void main(String[] args) {
        new TimeProxy(new Pony()).paint();
    }
}

运行结果:

小马画月牙
paint 画画耗时:3221毫秒

Process finished with exit code 0

大家想想,这样写有什么缺陷没有?

有的,这里只是持有了Pony的对象,也就是说这个代理只能代理Pony画画的时间处理,事实上,这个TimeProxy也能代理Puppy等其他小画家的,那如何做呢?

把具体的Pony对象换成抽象的Painter,Teacher想看谁画画就给代理传哪个画家就行了!
改一下TimeProxy:

public class TimeProxy implements Painter {
    private Painter painter;

    public TimeProxy(Painter painter) {
        this.painter = painter;
    }

    @Override
    public void paint() {
        long start = System.currentTimeMillis();
        painter.paint();
        long end = System.currentTimeMillis();
        System.out.println("paint 画画耗时:" + (end - start) + "毫秒");
    }
}

这次调用小狗Puppy来画:

new TimeProxy(new Puppy()).paint();
小狗画梅花
paint 画画耗时:2152毫秒

Process finished with exit code 0

very ok 了!别急,来把日志的代理也加进去。

public class LogProxy implements Painter {
    private Painter painter;

    public LogProxy(Painter painter) {
        this.painter = painter;
    }

    @Override
    public void paint() {
        System.out.println("日志:开始作画");
        painter.paint();
        System.out.println("日志:画完了");
    }
}

现在想一下,Teacher该怎么调用这两个代理,既能打印运行时间,又能打印处理日志,还能画画?

我们看一下代理的构造方法,他里面传的是抽象的画家,并不是具体的,而代理本身也是一种特殊的画家-代理本身是实现Painter这个接口的,所以调用的时候可以把代理作为参数传递到另一个代理!!!

public class Teacher {
    public static void main(String[] args) {
        //new TimeProxy(new Puppy()).paint();
        new TimeProxy(new LogProxy(new Puppy())).paint();
    }
}

运行:

日志:开始作画
小狗画梅花
日志:画完了
paint 画画耗时:8489毫秒

Process finished with exit code 0

既有日志处理,又有时间处理,还有画画本身的逻辑处理,大功告成!

在这里插入图片描述

上面的例子诠释了一种设计模式-代理模式,这是一种静态代理模式。

动态代理

从前面的例子我们可以看到,静态代理只能作为某一特定的接口的代理,比如前面的TimeProxy只能代理Painter。

像这种记录执行时间的操作,应该可以应用于所有对象的方法上,具有普遍性,如果要实现把TimeProxy使用到别的地方,其他Object,该怎么做呢?

分离代理行为与被代理对象,使用jdk的动态代理。

JDK的动态代理

在这里插入图片描述

jdk的 Proxy 类来自于 java.lang.reflect 包,没错,就是大名鼎鼎的 反射机制 ,反射是根据已经编译好的二进制字节码来分析类的属性和方法,只要给我一个 .class 我就能分析出他的内容。

上代码:

public class Teacher {
    public static void main(String[] args) {
        Pony pony = new Pony();
        Painter painter = (Painter) Proxy.newProxyInstance(
                Pony.class.getClassLoader(),
                Pony.class.getInterfaces(),//new Class[]{Painter.class}
                new TimeProxyHandler(pony));
        painter.paint();
    }
}

Proxy.newProxyInstance有三个参数,第一个是被代理类的类加载器,第二个是实现的接口数组,也可以写成:

new Class[]{Painter.class}

重点是第三个参数,该参数是一个InvocationHandler,动态代理方法在执行时,会调用InvocationHandler类里面的invoke方法去执行。

类TimeProxyHandler的具体实现:

public class TimeProxyHandler implements InvocationHandler {
    private Pony pony;

    public TimeProxyHandler(Pony pony) {
        this.pony = pony;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long start = System.currentTimeMillis();
        Object o = method.invoke(pony, args);
        long end = System.currentTimeMillis();
        System.out.println("执行耗时:" + (end - start) + "毫秒");
        return o;
    }
}

执行Teacher.main()运行结果:

小马画月牙
执行耗时:7881毫秒

Process finished with exit code 0

以上我们是用JDK的动态代理可以分离代理行为和被代理的对象,这里的Pony可以换成其他对象。

我的main方法里只调用了painter.paint();啊,怎么连执行耗时:7881毫秒这句话也打印出来了呢?

JDK动态代理原理分析

运行结果打印了执行耗时:7881毫秒,说明程序必然运行了TimeProxyHandler的invoke方法,我们来分析一下下面这句:

Painter painter = (Painter) Proxy.newProxyInstance(
                Pony.class.getClassLoader(),
                //new Class[]{Painter.class}
                Pony.class.getInterfaces(),
                new TimeProxyHandler(pony));

Proxy.newProxyInstance这一句创建了一个中间类,我们通过如下手段System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”)把它弄出来看看:

public class Teacher {
    public static void main(String[] args) {
        Pony pony = new Pony();
        //将proxy内部调用invoke方法 生成的中间类 保存下来
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        Painter painter = (Painter) Proxy.newProxyInstance(
                Pony.class.getClassLoader(),
                new Class[]{Painter.class},
                new TimeProxyHandler(pony));
        painter.paint();
    }
}

再次运行,发现项目目录多了这个:

在这里插入图片描述

打开 $Proxy0 看看,就能明白个差不多了

public final class $Proxy0 extends Proxy implements Painter {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

jdk帮我们生成的 $Proxy0 继承 Proxy 实现 Painter:

static {
    try {
        m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
        m3 = Class.forName("com.xblzer.dp.proxy.dynamicproxy.Painter").getMethod("paint");
        m2 = Class.forName("java.lang.Object").getMethod("toString");
        m0 = Class.forName("java.lang.Object").getMethod("hashCode");
    } catch (NoSuchMethodException var2) {
        throw new NoSuchMethodError(var2.getMessage());
    } catch (ClassNotFoundException var3) {
        throw new NoClassDefFoundError(var3.getMessage());
    }
}

...

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

当我们 main 里面调用 painter.paint() 时,实际上执行了 super.h.invoke(this, m3, (Object[])null) ,这里的 m3 :

m3 = Class.forName("com.xblzer.dp.proxy.staticproxy.Painter").getMethod("paint");

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

技术杠精

你的鼓励是我创作最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值