为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 设计模式-静态代理与动态代理

设计模式-静态代理与动态代理

标签：
设计模式

  • 静态代理: 由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

  • 动态代理: 在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。

情境

假设，有个汽车类具有移动和停止两个方法，我们要怎么在不改动源码的情况下：

1.添加日志

2.添加事务

IMovable.java

public interface IMovable {    void move();    void stop();
}

Car.java

public class Car implements IMovable {    @Override
    public void move() {
        System.out.println("汽车移动");
    }    @Override
    public void stop() {
        System.out.println("汽车停止");
    }
}

静态代理

继承

1.添加日志

CarLog.java

public class CarLog extends Car {    @Override
    public void move() {
        System.out.println("开始执行move");        super.move();
        System.out.println("执行move完成");
    }    @Override
    public void stop() {
        System.out.println("开始执行stop");        super.stop();
        System.out.println("执行stop完成");
    }
}

Client.java

public class Client {
    public static void main(String[] args) {
        IMovable log = new CarLog();        log.move();        log.stop();
    }
}

  • 从上面的代码可以看出，我们定义了一个类并且继承于Car

  • 重写父类中的方法，在super(调用父类中的方法)前后加入打印日志的代码

运行截图:

webp

静态代理_继承_日志.png

2.添加事务

CarTransaction.java

public class CarTransaction extends Car {    @Override
    public void move() {
        System.out.println("move事务开始");        super.move();
        System.out.println("move事务提交");
    }    @Override
    public void stop() {
        System.out.println("stop事务开始");        super.stop();
        System.out.println("stop事务提交");
    }
}

运行结果:

webp

静态代理_继承_事务.png

  • 很明显，对于事务的做法与日志的做法一致

3.先添加日志再开启事务

CarLog2Trans.java

public class CarLog2Trans extends CarTransaction{    @Override
    public void move() {
        System.out.println("开始执行move");        super.move();
        System.out.println("执行move完成");
    }    @Override
    public void stop() {
        System.out.println("开始执行stop");        super.stop();
        System.out.println("执行stop完成");
    }
}

运行结果:

webp

静态代理_继承_先日志后事务.png

4.先开启事务再添加日志

CarTrans2Log.java

public class CarTrans2Log extends CarLog {    @Override
    public void move() {
        System.out.println("move事务开始");        super.move();
        System.out.println("move事务提交");
    }    @Override
    public void stop() {
        System.out.println("stop事务开始");        super.stop();
        System.out.println("stop事务提交");
    }
}

运行结果:

webp

静态代理_继承_先事务后日志.png

  • 从上面代码可以看出如果我们添加功能的话，就要创建新的类

情境: 有四辆汽车A,B,C,D，A汽车要做到先添加日志再开启事务，B汽车要做到先开启事务再添加日志,C汽车只需要添加日志，D汽车只需要开启事务

显然为了完成这样的功能使用继承的方式，我们必须要有四个类才能完成，哪有没有更好的方式呢？

接口(聚合)

1.添加日志

CarLogProxy.java

public class CarLogProxy implements IMovable {    private IMovable movable;    public CarLogProxy(IMovable movable) {        this.movable = movable;
    }    @Override
    public void move() {
        System.out.println("开始执行move");
        movable.move();
        System.out.println("执行move完成");
    }    @Override
    public void stop() {
        System.out.println("开始执行stop");
        movable.stop();
        System.out.println("执行stop完成");
    }
}

Client.java

public class Client {
    public static void main(String[] args) {
        IMovable movable = new Car();
        IMovable log = new CarLogProxy(movable);        log.move();        log.stop();
    }
}

  • 从上面的代码可以看出，我们实现了IMovable接口(目标接口)，并传入了需要被代理的对象

2.添加事务

CarTransactionProxy.java

public class CarTransactionProxy implements IMovable {
private IMovable movable;

public CarTransactionProxy(IMovable movable) {    this.movable = movable;
}@Overridepublic void move() {
    System.out.println("move事务开始");
    movable.move();
    System.out.println("move事务提交");
}@Overridepublic void stop() {
    System.out.println("stop事务开始");
    movable.stop();
    System.out.println("stop事务提交");
}

}

Client.java

public class Client {
    public static void main(String[] args) {
        IMovable movable = new Car();
        IMovable transaction = new CarTransactionProxy(movable);
        transaction.move();
        transaction.stop();
    }
}

3.先添加日志再开启事务

Client.java

public class Client {
    public static void main(String[] args) {
        IMovable movable = new Car();
        IMovable transaction = new CarTransactionProxy(movable);
        IMovable log = new CarLogProxy(transaction);        log.move();        log.stop();
    }
}

4.先开启事务再添加日志

Client.java

public class Client {
    public static void main(String[] args) {
        IMovable movable = new Car();
        IMovable log = new CarLogProxy(movable);
        IMovable transaction = new CarTransactionProxy(log);
        transaction.move();
        transaction.stop();
    }
}

  • 从3与4的Client可以看出，使用聚合的办法就只要用两个类就能实现需求

  • 显然，使用实现目标接口的方式进行代理，让代理和被代理对象之间都可以相互灵活转换

  • 所以一般静态代理使用聚合的方式进行实现，使用继承的方式多多少少有些过于笨重

想必认真的人都看的出来，静态代理的方式随着功能的增多，必然要生成更多的代理对象，这样不利于维护。而且，就目前的要求来看，对 move() 和 stop() 两个方法添加日志，其中代码出现了冗余的情况，无法复用。那么有什么方式可以解决呢？

动态代理

Client.java

public class Client {    public static void main(String[] args) {
        IMovable movable = new Car();
        IMovable logProxy = (IMovable) Proxy.newProxyInstance(Car.class.getClassLoader(), Car.class.getInterfaces(),                new InvocationHandler() {                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开始执行" + method.getName());
                        Object invoke =method.invoke(movable, args);
                        System.out.println("执行" + method.getName() + "完成");                        return invoke;
                    }
                });
        logProxy.move();
        logProxy.stop();
        
        System.out.println();

        IMovable transProxy = (IMovable) Proxy.newProxyInstance(Car.class.getClassLoader(), Car.class.getInterfaces(),                new InvocationHandler() {                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println(method.getName() + "开启事务");
                        Object invoke = method.invoke(logProxy, args);
                        System.out.println(method.getName() + "事务提交");                        return invoke;
                    }
                });
        transProxy.move();
        transProxy.stop();
    }
}

运行结果:

webp

动态代理.PNG

  • 从运行结果来看，我们使用动态代理实现了上面静态代理的例子，且没有编写多余的类

  • 从上面的代码可以看出，要使用动态代理就必须要有目标接口

  • 在 InvocationHandler 的方法中可以获取要执行的 Method 实例

  • 通过 Method 的实例可以通过反射来执行，不过要传入被代理对象

  • 在反射前后可以进行添加日志和事务的操作

  • 而且也可以灵活的让进行代理对象与被代理对象之间的转换

  • 由于使用了反射，对性能有一定的损耗

动态代理源码解析

对于动态代理的源码其实最重要的就是下面两个方法，我们下面开始对他们进行深入分析，做到知其然知其所以然。

Proxy.newProxyInstance 部分代码

 public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException{
     ...
     
     Class<?> cl = getProxyClass0(loader, intfs);     try {
        ...        
        final Constructor<?> cons = cl.getConstructor(constructorParams);        final InvocationHandler ih = h;
        ...        

            return cons.newInstance(new Object[]{h});
        }catch (IllegalAccessException|InstantiationException e) {        throw new InternalError(e.toString(), e);
        }
        ...
        
}

  • loader 定义代理类的类加载器

  • interfaces 代理类要实现的接口列表

  • h  指派方法调用的调用处理程序(注:动态代理的关键)

  • 将其他多余的部分代码忽略，找核心的代码(因为有些偏底层我也看不懂 -.- )

  • getProxyClass0(loader, intfs); 获得代理类

  • cl.getConstructor(constructorParams); 获得代理类的构造方法

  • cons.newInstance(new Object[]{h}); 反射生成代理对象，并传入 InvocationHandler

所以我们往下看看它是如何得到代理对象的

Proxy.getProxyClass0 代码

    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
    proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());    
    private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {    if (interfaces.length > 65535) {        throw new IllegalArgumentException("interface limit exceeded");
    }    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    return proxyClassCache.get(loader, interfaces);

  • 注释翻译: 如果存在给定接口的给定装入器定义的代理类存在，则只返回缓存的副本；否则，它将通过proxyclassfactory创建代理类

所以我们就要进一步分析 (proxyClassCache)WeakCache 类是怎么进行缓存的。(个人能力有限对于WeakCache还有较多疑惑，之后会进行总结更新)



作者：请叫我张懂
链接：https://www.jianshu.com/p/f59a37984b27


点击查看更多内容
发表于 2019.02.16 23:37， 共 1712 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

慕姐8265434

手记
篇
粉丝
221
获赞与收藏
1064

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消