设计模式私家笔记——装饰器Decorator和代理Proxy不是两兄弟

刚学习设计模式的时候，容易对装饰器模式和代理模式有所混淆，所以笔者特意将两者放在一起进行讲解，对比其相似性及区别。

装饰器模式 Decorator Pattern

我们最初接触装饰器模式，可能是在学习Java的IO相关操作的时候，下面一些类大家或多或少都使用过：

• java.io.BufferedInputStream(InputStream)
• java.io.DataInputStream(InputStream)
• java.io.BufferedOutputStream(OutputStream)
• java.util.zip.ZipOutputStream(OutputStream)
• java.util.Collections#checkedList|Map|Set|SortedSet|SortedMap

这些类能够帮助我们在文件、字符和流的操作之间进行快捷切换。

这时候再看装饰器模式（Decorator Pattern）的理解，该模式能够动态为一些类追加或扩展某些行为，比如下面的例子所示，一个基础的Shape类的实现（Circle、Rectangle）能够将自己描绘出来，此时我们想给这些形状加上红色的边框，该如何处理呢？

典型的想法可能是，我们声明一个接口Border，然后再用两个类分别继承Circle和Rectangle并实现Border接口，这样做显得比较繁琐，如果再有其他的形状，我们还要多些几个类。

装饰器模式给我们提供了一种更为灵活的扩展方式，我们直接通过代码来感受一下

interface Shape {
  void draw();
}
class Circle implements Shape {
  public class Circle() {}
  @Override
  public void draw() {
    System.out.println("A circle draws");
  }
}
class Rectangle implements Shape {
  public class Rectangle() {}
  @Override
  public void draw() {
    System.out.println("A rectangle draws");
  }
}

上面已经有了基础的形状的实现，此时我们再定义一个边框装饰器

class BorderDecorator implements Shape {
  private Shape shape;
  public class BorderDecorator(Shape shape) {
    this.shape = shape;
  }
  @Override
  public void draw() {
    shape.draw();
    System.out.println("Shape's border draws");
  }
}

这样当我们需要增加边框时，只要这样应用即可

class DecoratorPatternDemo {
  public static void main(String[] args) {
    Shape circle = new Circle();
    Shape borderCircle = new BorderDecorator(circle);
    circle.draw();
    borderCircle.draw();
    
    Shape rectangle = new Rectangle();
    Shape borderRectangle = new BorderDecorator(rectangle);
    rectangle.draw();
    borderRectangle.draw();
    
    /*
     * 输出结果为：
     * A circle draws
     * Shape's border draws
     * A rectangle draws
     * Shape's border draws
     */
  }
}

代理模式 Proxy Pattern

在现实生活中，我们很不少被代理的事情发生，比如有人借了我们的钱不还，我们不熟悉诉讼的过程或者没有时间去进行诉讼的所有过程，此时我们可以委托律师代理我们进行相关的诉讼过程；再或者，我们初到一个城市工作，我们会找一个房产中介来代理我们去租赁或者购买适合我们的房子。

这是代理就像是我们的一个替身或者代言人一样，它可以以我们的名义做很多事情，还能够控制或安排我们本人去执行具体的一些动作。

代理模式主要解决的时，直接访问一个类代理的一些问题或局限，比如做一些缓存控制，做一些安全检查，做一些事务控制等。我们举一个网络传输中的例子，在浏览器等设备加载图片时，如果网络环境不良或者图片体积过大时，我们通常会在最终图片显示前，给用户展示一张临时的低清图片来过渡，以提升用户交互体验。

interface Image {
  void display();
}

interface HighSolutionImage implements Image {
  private String imageUrl;
  private long loadStartTime;
  public HighSolutionImage(String imgUrl) {
    this.imageUrl = imgUrl;
    loadStartTime = System.currentTimeMillis();
    requestImage();
  }
  @Override
  public void display() {
    System.out.println("HighSolutionImage displays：" + imgUrl);
  }
  
  private void isLoading() {
    return System.currentTimeMillis() - loadStartTime < 5;
  }
}

在不进行代理前，高分辨率图片只能等到完全加载好之后才进行展示

注：此处我们简化处理，展示只是简单打印出路径，但笔者想表达的是类似HTML的 <img>标签的src加载资源的过程，只有当图片完全传输过来才进行展示，在此之前，都是空白或者没有空间

class ImageProxy implements Image {
  	private String tempImgUrl = "cdn-temp.jpg";
    private HighResolutionImage hrImage;

    public ImageProxy(String imgUrl) {
        this.hrImage = new HighResolutionImage(imgUrl);
    }

    @Override
    public void showImage() {
        while (hrImage.isLoading()) {
            try {
                System.out.println("Temp Image displays: " + tempImgUrl);
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        hrImage.showImage();
    }
}

代理类ImageProxy在高清图最终加载前，做了友好交互的控制，并且在高分辨率图片加载完时，调用HighResolutionImage的本身行为进行展示。

比较

其实装饰器和代理的区别挺微妙的，笔者的建议是大家先重点关注语义上的区别，装饰器强调的是增加原有对象，给他添加更多功能和特性，而代理强调的是对被代理对象的控制和管理，所以首先是语义上的区别。

另外，另外就是实现角度的细微区别 😃，装饰器模式下我们是知道被代理对象的，需要显式的传递给装饰器；而代理模式下，被代理对象通常是被隐藏的（为了避免直接访问带来的问题）。所以形式上，一般的，装饰器通过构造器直接传递被装饰对象，而访问代理时，我们可能都不知道我们访问的是代理。