设计模式九之装饰者模式

  在现实生活中，常常需要对现有产品增加新的功能或美化其外观，如房子装修、相片加相框等。在软件开发过程中，有时想用一些现存的组件。这些组件可能只是完成了一些核心功能。但在不改变其结构的情况下，可以动态地扩展其功能。所有这些都可以釆用装饰模式来实现。

1. 模式的定义与特点

1.1 模式的定义

  装饰者模式（Decorator）：在不改变现有对象结构的情况下，动态的给该对象增加一些指责（即增加额外功能）。装饰者模式提供了比继承更有弹性的替代方案（扩展原有对象的功能）。

1.2 模式的特点

  装饰者模式的优点有：
    1. 继承的有力补充，比继承灵活，在不改变原有对象的情况下给对象扩展功能；
    2. 通过使用不同的装饰类以及这些装饰类的排列组合，可以实现不同的效果；
    3. 符合开闭原则。

  装饰者模式的缺点有：
    1. 会出现更多的代码，更多的类，增加程序的复杂性；
    2. 动态装饰时，多层装饰时会更复杂。

1.3 模式的使用场景

  1. 扩展一个类的功能或给一个类添加附加职责时；
  2. 动态的给一个对象添加功能，这些功能也可以在动态的撤销。

2. 模式的结构与实现

2.1 模式的结构

  通常情况下，扩展一个类的功能会使用继承方式来实现。但继承具有静态特征，耦合度高，并且随着扩展功能的增多，子类会很膨胀。如果使用组合关系来创建一个包装对象（即装饰对象）来包裹真实对象，并在保持真实对象的类结构不变的前提下，为其提供额外的功能，这就是装饰模式的目标。
  装饰者模式的主要角色如下：
    1. 抽象对象（Abstract Object）：定义一个抽象接口以准备接收附加责任的对象；
    2. 具体对象（Concrete Object）：实现抽象对象，通过装饰角色为其添加一些职责；
    3. 抽象装饰（Abstract Decorator）：继承抽象对象，并包含具体对象的实例，可以通过其子类扩展具体对象的功能；
    4. 具体装饰（Concrete Decorator）：实现抽象装饰的相关方法，并给具体对象添加附加的责任。

2.2 模式的实现

抽象对象

/**
 * 抽象对象 - 煎饼
 */
public abstract class APancake {

    /**
     * 描述
     * @return
     */
    public abstract String desc();

    /**
     * 价格
     * @return
     */
    public abstract int cost();

}

具体对象

/**
 * 具体对象 - 煎饼
 */
public class Pancake extends APancake {

    @Override
    public String desc() {
        return "煎饼";
    }

    @Override
    public int cost() {
        return 8;
    }
}

抽象装饰

/**
 * 抽象装饰
 */
public abstract class AbstractDecorator extends APancake {

    private APancake pancake;

    public AbstractDecorator(APancake pancake) {
        this.pancake = pancake;
    }

    @Override
    public String desc() {
        return pancake.desc();
    }

    @Override
    public int cost() {
        return pancake.cost();
    }
}

具体装饰

/**
 * 具体装饰 - 给煎饼加鸡蛋
 */
public class EggDecorator extends AbstractDecorator {

    public EggDecorator(APancake pancake) {
        super(pancake);
    }

    @Override
    public String desc() {
        return super.desc() + " 加一个鸡蛋";
    }

    @Override
    public int cost() {
        return super.cost() + 2;
    }
}

/**
 * 具体装饰 - 给煎饼加跟香肠
 */
public class SausageDecorator extends AbstractDecorator {

    public SausageDecorator(APancake pancake) {
        super(pancake);
    }

    @Override
    public String desc() {
        return super.desc() + " 加跟香肠";
    }

    @Override
    public int cost() {
        return super.cost() + 5;
    }
}

客户端

public class client {

    public static void main(String[] args) {
        APancake pancake = new SausageDecorator(new EggDecorator(new EggDecorator(new Pancake())));
        System.out.println(pancake.desc() + " ， 价格共计：" + pancake.cost());
    }

}

# 运行结果如下：
煎饼 加一个鸡蛋 加一个鸡蛋 加跟香肠 ， 价格共计：17

3. 模式在开源软件中的应

3.1 java.io.BufferedReader 类

public class BufferedReader extends Reader {

    private Reader in;

    public BufferedReader(Reader in, int sz) {
        super(in);
        if (sz <= 0)
            throw new IllegalArgumentException("Buffer size <= 0");
        this.in = in;
        cb = new char[sz];
        nextChar = nChars = 0;
    }
}  

  其实在 java.io 包下大量运用了装饰者模式，在 IO 的读取写我们经常会 new ObjectInputStream(new FileInputStream()) 这种的都是装饰者模式下的应用。

3.2 springframework...TransactionAwareCacheDecorator

public class TransactionAwareCacheDecorator implements Cache {
    private final Cache targetCache;

    public TransactionAwareCacheDecorator(Cache targetCache) {
        Assert.notNull(targetCache, "Target Cache must not be null");
        this.targetCache = targetCache;
    }
}   

3.3 org.apache.ibatis.cache.*.BlockingCache 类

public class BlockingCache implements Cache {

  private long timeout;
  private final Cache delegate;
  private final ConcurrentHashMap<Object, ReentrantLock> locks;

  public BlockingCache(Cache delegate) {
    this.delegate = delegate;
    this.locks = new ConcurrentHashMap<Object, ReentrantLock>();
  }

  @Override
  public String getId() {
    return delegate.getId();
  }

  @Override
  public int getSize() {
    return delegate.getSize();
  }

  @Override
  public void putObject(Object key, Object value) {
    try {
      delegate.putObject(key, value);
    } finally {
      releaseLock(key);
    }
  }
}