设计模式------装饰者设计模式（IO流的应用）

Posted 2021-01-08 qingruihappy

一：io流中的装饰者设计模式

java.io包内的类太多了，简直是……"排山倒海"。你第一次（还有第二次和第三次）看到这些API发出"哇"的惊叹时，放心，你不是唯一受到惊吓的人。现在，你已经知道装饰者模式，这些I/O的相关类对你来说应该更有意义了，因为其中许多类都是装饰者。下面是一个典型的对象集合，用装饰者来将功能结合起来，以读取文件数据：

我们来看一下下面的这张类图

你可以发现，和星巴兹的设计相比，java.io其实没有多大的差异。我们把java.ioAAPI范围缩小，让你容易查看它的文件，并组合各种"输入"流装饰者来符合你的用途。

你会发现"输出"流的设计方式也是一样的。你可能还会发现Reader/Writer流（作为基于字符数据的输入输出）和输入流/输出流的类相当类似（虽然有一些小差异和不一致之处，但是相当雷同，所以你应该可以了解这些类）。

但是JavaAI/O也引出装饰者模式的一个"缺点"：利用装饰者模式，常常造成设计中有大量的小类，数量实在太多，可能会造成使用此API程序员的困扰。但是，现在你已经了解了装饰者的工作原理，以后当使用别人的大量装饰的API时，就可以很容易地辨别出他们的装饰者类是如何组织的，以方便用包装方式取得想要的行为。

1.1，下面我们结合着BufferedInputStream和 BufferedOutputStream来分析一下装饰着设计模式代码很简单，主要看得就是它的源码

public class Test {

    public static void copyMp3() {

         try {

              FileInputStream fi = new FileInputStream("audio.mp3");

              BufferedInputStream buf = new BufferedInputStream(fi);

              FileOutputStream fio = new FileOutputStream("audioCapy.mp3");

              BufferedOutputStream buo = new BufferedOutputStream(fio);

              int ch = 0;

              while ((ch = buf.read()) != -1) {

                   buo.write(ch);

              }

              buf.close();

              buo.close();

         } catch (FileNotFoundException e) {

              e.printStackTrace();          } catch (IOException e) {

              e.printStackTrace();

         }

    }

}

BufferedInputStream buf = new BufferedInputStream(new FileInputStream("audio.mp3"));

我们来看一下这行代码

private static int defaultBufferSize = 8192;

public BufferedInputStream(InputStream in) {

this(in, defaultBufferSize);

}

初始化的时候就会进来这个方法中。

在进一层可以看到这行代码，意思就是把buf的数组长度复制为8192

public BufferedInputStream(InputStream in, int size) {

super(in);

if (size <= 0) {

throw new IllegalArgumentException("Buffer size <= 0");

}

buf = new byte[size];

}

下面我们来看这行代码。

buf.read()

public synchronized int read() throws IOException {

if (pos >= count) {

fill();

if (pos >= count)

return -1;

}

return getBufIfOpen()[pos++] & 0xff;

}

private byte[] getBufIfOpen() throws IOException {

byte[] buffer = buf;

if (buffer == null)

throw new IOException("Stream closed");

return buffer;

}

实际上返回的getBufIfOpen就是我们上面构造方法中的初始化的数组8192 下面我们来看fill()的方法

private void fill() throws IOException {

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 { /* grow buffer */ int nsz = pos * 2; 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; int n = getInIfOpen().read(buffer, pos, buffer.length - pos); if (n > 0) count = n + pos; }

我们来看getInIfOpen().read(buffer, pos, buffer.length - pos)这行代码，具体的逻辑实现我们先不管，主要就是研究装饰者设计模式的。

private InputStream getInIfOpen() throws IOException { InputStream input = in; if (input == null) throw new IOException("Stream closed"); return input; }

在这里我们就确定了getInIfOpen是要返回的就是BufferedInputStream buf = new

BufferedInputStream(new FileInputStream("audio.mp3"));中的FileInputStream，现在我们去 fileinputstream中来找read(buffer, pos, buffer.length - pos)方法。

protected volatile InputStream in;

public int read(byte b[], int off, int len) throws IOException { return in.read(b, off, len);

}

这个时候我们就可以看到这里的in就是inputStream最里面的核心的要被装饰的类。

现在我们在到inputStream的源码中来可以看到就是这样的。

public int read(byte b[], int off, int len) throws IOException { if (b == null) { throw new NullPointerException(); } else if (off < 0 || len < 0 || len > b.length - off) { throw new IndexOutOfBoundsException(); } else if (len == 0) { return 0; } int c = read(); if (c == -1) { return -1; } b[off] = (byte)c; int i = 1; try { for (; i < len ; i++) { c = read(); if (c == -1) { break; } b[off + i] = (byte)c; } } catch (IOException ee) { } return i; }

从上面的一整套的逻辑我们可以看到，BufferedInputStream的read方法扩展了核心的类 inputStream的功能，这个就是典型的装饰着设计模式，其实io流中有都是基于

InputStream的装饰着模式的扩张的应用的。

1.2，下面我们自己来定义一个流的类基于BufferedInputStream的在装饰

就是把首字符变成小写的。

LowerCaseInputStream.java

package com.DesignPatterns.ac.decorator_io; import java.io.*; public class LowerCaseInputStream extends FilterInputStream {     public LowerCaseInputStream(InputStream in) {          super(in);     }     public int read() throws IOException {          int c = in.read();          return (c == -1 ? c : Character.toLowerCase((char) c));     }     public int read(byte[] b, int offset, int len) throws IOException {          int result = in.read(b, offset, len);          for (int i = offset; i < offset + result; i++) {               b[i] = (byte) Character.toLowerCase((char) b[i]);          }          return result;     } }

Test

package com.DesignPatterns.ac.decorator_io; import java.io.*; public class InputTest {     public static void main(String[] args) throws IOException {          int c;

         try {

              InputStream in = new LowerCaseInputStream(new

BufferedInputStream(new FileInputStream("test.txt")));

              while ((c = in.read()) >= 0) {

                   System.out.print((char) c);

              }

              in.close();

         } catch (IOException e) {

              e.printStackTrace();

         }

    }

}

in.read(b, offset, len)这一行代码的装饰着设计模式我们上面说过了，就不在说了，那我们就主要的来看这里的再次装饰的逻辑

for (int i = offset; i < offset + result; i++) {

              b[i] = (byte) Character.toLowerCase((char) b[i]);

         }

当经过一次装饰之后我们再次对输出的结果进行修改，相当于又套了一个马甲又多了一个功能。这个就是典型的装饰着设计模式。 fff