javaIO的装饰者模式

装饰者模式的uml

• 通过继承和组合的方式来设计类的修饰作用
• 在继承的基础上，通过引用让对象具有多重修饰（拥有其他子类的方法）的特性。
  
  这个类图是《Head first 设计模式》上的例子
  装饰者的魔力主要在于CondimentDecorator的身上，它是抽象的装饰者类。继承CondimentDecorator在构造方法上都引用了Baverage抽象类。

抽象的Beverage类

public abstract class Beverage {

    //星巴兹咖啡店新增了小杯、中杯、大杯的咖啡规格。
    public static final int small = 1;
    public static final int middle = 2;
    public static final int large = 3;

    String description;
    private double sizeCost = 0D;
    private String sizeDescription = "";

    public void setSize(int size){
        if (size == small){
            sizeCost = 0.1;
            sizeDescription = "小杯";
        }else if (size == middle){
            sizeCost = 0.2;
            sizeDescription = "中杯";
        }else if (size == large){
            sizeCost = 0.3;
            sizeDescription = "大杯";
        }
    }

    public Double getSize(){
        return sizeCost;
    }

    public String getDescription(){
        return sizeDescription + this.description;
    }

    //不同的价格，由子类来说明
    public abstract Double cost();
}

不具有装饰的子类（只列举一个）

public class DarkRoast extends Beverage{

    public DarkRoast(){
        description = "深焙咖啡";
    }

    public Double cost() {
        return super.getSize() + 0.89;
    }
}

装饰者的抽象类

可以根据自身业务，来定义要实现的抽象方法

public abstract class CondimentDecorator extends Beverage{
    //对被装饰的了饮料的描述
    public abstract String getDescription();
}

具有装饰效果的子类

public class Mocha extends CondimentDecorator {

   //引入父类，让装饰者对象都有其父类的特性
    private Beverage beverage;

    private Mocha(){}
    public Mocha(Beverage beverage){
        this.beverage = beverage;
    }
    public String getDescription() {
        return this.beverage.getDescription() + ", 摩卡";
    }
    public Double cost() {
        return this.beverage.cost() + 0.2;
    }

}

装饰者的魔力体验

public class DecoratorMain {

    public static void main(String[] args) {
        //来大杯的双倍摩卡综合咖啡
        Beverage beverage = new HouseBlend();
        beverage.setSize(3);
        beverage = new Mocha(beverage);
        beverage = new Mocha(beverage);
        System.out.println("描述：" + beverage.getDescription() + "。 价格："+beverage.cost());
    }
}

以上将一个子类对象经过多重修饰，获得一个想要达到的目标。

javaIO中的装饰者模式设计

java对io操作的API中有根据读取方向分为输入流(InputStream)和输出流(OutputStream)，我们从InputStream来开始分析。

InputStream的uml图

从java的io包中找出*InputStream类来对其进行uml设计关系的分析。
* 具有装饰功能的类都继承自FilterInputStream类，他们的子类都持有InputStream类的引用
* 其余的子类对象例如FileInputStream类和ByteArrayInputStream类都是正常的子类实现，直接继承自InputStream。

分析BufferedInputStream类

从调用入口开始入手分析

//inputStream只能按照字节来读取,因此读取中文的时候会出现乱码
    public void useBufferedInputStream() throws IOException {
        String str = "fdsggdsk";
        byte[] bytes = str.getBytes("utf-8");
        BufferedInputStream bis = new BufferedInputStream(new ByteArrayInputStream(bytes));
        int c ;
        StringBuffer sb = new StringBuffer();
        while ((c = bis.read()) >= 0 ){
            sb.append((char) c);
        }
        System.out.println("sb.toString() = " + sb.toString());
    }

这里创建了两个InputStream子类的实例
1. new ByteArrayInputStream(bytes)
2. new BufferedInputStream(new ByteArrayInputStream(bytes))
3. 调用BufferedInputStream的read方法
ByteArrayInputStream的read方法是一个字节一个字节的读取内容，而BufferInputStream的read方法，是将所有的字节缓冲到buf[]数组中，然后再依次读取
通过源码可以了解

public synchronized int read() throws IOException {
//先判断数组指针和count是否相等，如果pos == count，当使用
//read()方法读取到缓冲区的末尾时，会使用fill()方法再次预先读入
//一部分字节
        if (pos >= count) {
            fill();
            if (pos >= count)
                return -1;
        }
        return getBufIfOpen()[pos++] & 0xff;
    }

 byte[] buffer = getBufIfOpen();
        if (markpos < 0)
            pos = 0;            /* no mark: throw away the buffer */
        else if (pos >= buffer.length)  /* no room left in buffer */
            if (markpos > 0) {  /* can throw away early part of the buffer */
                int sz = pos - markpos;
                System.arraycopy(buffer, markpos, buffer, 0, sz);
                pos = sz;
                markpos = 0;
            } else if (buffer.length >= marklimit) {
                markpos = -1;   /* buffer got too big, invalidate mark */
                pos = 0;        /* drop buffer contents */
            } else if (buffer.length >= MAX_BUFFER_SIZE) {
                throw new OutOfMemoryError("Required array size too large");
            } else {            /* grow buffer */
                int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
                        pos * 2 : MAX_BUFFER_SIZE;
                if (nsz > marklimit)
                    nsz = marklimit;
                byte nbuf[] = new byte[nsz];
                System.arraycopy(buffer, 0, nbuf, 0, pos);
                if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
                    // Can't replace buf if there was an async close.
                    // Note: This would need to be changed if fill()
                    // is ever made accessible to multiple threads.
                    // But for now, the only way CAS can fail is via close.
                    // assert buf == null;
                    throw new IOException("Stream closed");
                }
                buffer = nbuf;
            }
        count = pos;
        //这里调用InputStream的read方法，哪个子类实现该方法，
        //就调用它的实现。例如ByteArrayInputStream.read()
        int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
        if (n > 0)
            count = n + pos;

以上就是javaIO的装饰模式的实现例子。我们也可以通过集成字FilterInputStream来特定的IO读取方式。
实现一个将大写字母转换成小写的InputStream

LowerCaseInputStream类的实现

简单的实现，只实现了read()和read(byte[] b, int off, int len) 方法就可以了

public class LowerCaseInputStream extends FilterInputStream {
    /**
     * Creates a <code>FilterInputStream</code>
     * by assigning the  argument <code>in</code>
     * to the field <code>this.in</code> so as
     * to remember it for later use.
     *
     * @param in the underlying input stream, or <code>null</code> if
     *           this instance is to be created without an underlying stream.
     */
    protected LowerCaseInputStream(InputStream in) {
        super(in);
    }

    @Override
    public int read() throws IOException {
        int read = super.read();
        return read == -1 ? -1 : Character.toLowerCase((char)read);
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        int read = super.read(b, off, len);
        for (int i = off; i < off + len; i++){
            b[i] = (byte) Character.toLowerCase((char) b[i]);
        }
        return read;
    }
}

参考博客
http://blog.youkuaiyun.com/songwei128/article/details/23355045