静态代理

UML图

image.png

问题引入

  • 要获取坦克的运行时间
  • move方法为Movable接口中的方法
  • Tank实现了Movable接口并重写了move方法
  • 问题：如何在不改变move内部逻辑（即无法改变方法源码时）的情况下获取其运行时间？ ```java package com.mashibing.dp.proxy.v01;

import java.util.Random;

/**

  • 问题：我想记录坦克的移动时间

  • 简单的办法：修改代码，记录时间 */ public class Tank implements Movable {

    /**

    • 模拟坦克移动了一段儿时间 */ @Override public void move() {

      // long start = System.currentTimeMillis();

      System.out.println(“Tank moving claclacla…”); try {

      1.  Thread.sleep(new Random().nextInt(10000));

      } catch (InterruptedException e) {

      1.  e.printStackTrace();

      }

      // long end = System.currentTimeMillis(); // System.out.println(end - start);

      } }

interface Movable { void move(); }

  2. - benchmark：性能测试，找到性能最差的点（可能是整个程序中的某个方法）；但我们是拿不到源码
  3.    - 方案1：用继承，调用super.move(); 代码如下===>这种方法不好（慎用继承，因为耦合度太高）
  4. ```java
  5. package com.mashibing.dp.proxy.v04;
  7. import java.util.Random;
  9. /**
  10.  * 问题：我想记录坦克的移动时间
  11.  * 最简单的办法：修改代码，记录时间
  12.  * 问题2：如果无法改变方法源码呢？
  13.  * 用继承？
  14.  */
  15. public class Tank implements Movable {
  17.     /**
  18.      * 模拟坦克移动了一段儿时间
  19.      */
  20.     @Override
  21.     public void move() {
  22.         System.out.println("Tank moving claclacla...");
  23.         try {
  24.             Thread.sleep(new Random().nextInt(10000));
  25.         } catch (InterruptedException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  30.     public static void main(String[] args) {
  31.         new Tank2().move();
  32.     }
  33. }
  35. // 继承Tank重写move，并在其中通过super调用父类的move
  36. class Tank2 extends Tank {
  37.     @Override
  38.     public void move() {
  39.         long start = System.currentTimeMillis();
  40.         super.move();
  41.         long end = System.currentTimeMillis();
  42.         System.out.println(end - start);
  43.     }
  44. }
  46. interface Movable {
  47.     void move();
  48. }
  • 方案2：在main中测试（不好，因为对于有很多方法的大程序来说依然不方便）
  • 方案3：用聚合（静态代理，将tank对象聚合到中间代理人TankProxy中去）
    • 代理：买茅台，不直接去厂商买，而是代理人去厂商买，加价后再卖给我们消费者
    • 代理人帮忙多做了一点事，也做了一点自己的事，但是做的都是一件事，所以实现的都是同一个接口Movable（代理茅台，不能变成五粮液） ```java package com.mashibing.dp.proxy.v05;

import java.util.Random;

/**

  • 问题：我想记录坦克的移动时间
  • 最简单的办法：修改代码，记录时间
  • 问题2：如果无法改变方法源码呢？
  • 用继承？
  • v05:使用代理

  • 代理有各种类型：时间time、日志log */ public class Tank implements Movable {

    /**

    • 模拟坦克移动了一段儿时间 */ @Override public void move() { System.out.println(“Tank moving claclacla…”); try {

      1.  Thread.sleep(new Random().nextInt(10000));

      } catch (InterruptedException e) {

      1.  e.printStackTrace();

      } }

      public static void main(String[] args) { new TankTimeProxy(new Tank()).move(); new TankLogProxy(new Tank()).move(); } }

// 用聚合代替继承===>解耦 // 记录时间 class TankTimeProxy implements Movable {

  1. Tank tank;
  3. // 传入tank对象
  4. public TankTimeProxy(Tank tank) {
  5.     this.tank = tank;
  6. }
  8. @Override
  9. public void move() {
  10.     long start = System.currentTimeMillis();
  11.     tank.move();
  12.     long end = System.currentTimeMillis();
  13.     System.out.println(end - start);
  14. }

}

// 记录日志 class TankLogProxy implements Movable { Tank tank; @Override public void move() { System.out.println(“start moving…”); tank.move(); System.out.println(“stopped!”); } }

interface Movable { void move(); }

  2. <a name="MXGQu"></a>
  3. ## 将代理对象改成Movable类型（聚合对象改为接口类型）
  5. - 静态代理
  6. - 越来越像Decorator模式
  7. - 实现代理的各种组合（装饰器模式、cor责任链？）
  8. - 继承的组合无穷无尽，但是组合通过实现接口可以一个套一个，方便一些
  9.    - 即一个代理对另一个代理进行代理
  10.    - **代理的代理，多层代理**
  11. - 设计模式学到后面就是多态的简单运用了（融会贯通、相互融合）
  12. - 只是语义上有区分，本质上用的都是各种各样的多态
  13. ```java
  14. package com.mashibing.dp.proxy.v07;
  17. import java.util.Random;
  19. /**
  20.  * 问题：我想记录坦克的移动时间
  21.  * 最简单的办法：修改代码，记录时间
  22.  * 问题2：如果无法改变方法源码呢？
  23.  * 用继承？
  24.  * v05:使用代理
  25.  * v06:代理有各种类型
  26.  * 问题：如何实现代理的各种组合？继承？Decorator?
  27.  * v07:代理的对象改成Movable类型-越来越像decorator了
  28.  *
  29.  */
  30. public class Tank implements Movable {
  32.     /**
  33.      * 模拟坦克移动了一段儿时间
  34.      */
  35.     @Override
  36.     public void move() {
  37.         System.out.println("Tank moving claclacla...");
  38.         try {
  39.             Thread.sleep(new Random().nextInt(10000));
  40.         } catch (InterruptedException e) {
  41.             e.printStackTrace();
  42.         }
  43.     }
  45.     public static void main(String[] args) {
  47.         Tank t = new Tank();
  48.         TankTimeProxy ttp = new TankTimeProxy(t);
  49.         TankLogProxy tlp = new TankLogProxy(ttp);
  50.         tlp.move();
  52. //        new TankLogProxy(
  53. //                new TankTimeProxy(
  54. //                        new Tank()
  55. //                )
  56. //        ).move();
  57.     }
  58. }
  60. class TankTimeProxy implements Movable {
  61.     Movable m;
  63.     public TankTimeProxy(Movable m) {
  64.         this.m = m;
  65.     }
  67.     @Override
  68.     public void move() {
  69.         long start = System.currentTimeMillis();
  70.         m.move();
  71.         long end = System.currentTimeMillis();
  72.         System.out.println(end - start);
  73.     }
  74. }
  76. class TankLogProxy implements Movable {
  77.     Movable m;
  79.     public TankLogProxy(Movable m) {
  80.         this.m = m;
  81.     }
  83.     @Override
  84.     public void move() {
  85.         System.out.println("start moving...");
  86.         m.move();
  87.         long end = System.currentTimeMillis();
  88.         System.out.println("stopped!");
  89.     }
  90. }
  92. interface Movable {
  93.     void move();
  94. }

需求升级—->静态代理的不足

  • 如果有stop方法需要代理…===>需要修改的太多（改接口、该实现、改代理类）===>需要新增方法这就要修改代码了，违反了开闭原则
  • 让LogProxy可以重用，不仅可以代理Tank，还可以代理任何其他可以代理的类型 ===> Object
  • 日志记录===>时间计算是很多方法都需要的东西
  • 不能直接将Movable接口类型改为Object类型，因为使用接口的目的就是为了将代理方法和被代理方法对应起来，将接口改为Object之后，调用原方法不光要进行强制类型转换，而且不容易看出关系
  • 解决方案： 详见下一篇
    • 分离代理行为与被代理对象
    • 使用jdk的动态代理
    • cglib的动态代理