静以修身！

2015-01-08 09:27

从InputStream到ByteArrayInputStream

江苏无锡 缪小东

本篇主要分析：1.如何将byte数组适配至ByteArrayInputStream，对应与IO部分的适配器模式；2.BufferedInputStream的工作原理，对应于IO的装饰器模式，会首先研究InputStream和FilterInputStream的源代码，同时会将要谈谈软件设计中的缓存相关的知识。后面专门一章分析PipedInputStream和PipedOutStream，简单谈谈管道相关的知识，以及软件架构的想法。

1 InputStream

InputStream 是输入字节流部分，装饰器模式的顶层类。主要规定了输入字节流的公共方法。

package java.io;

public abstract class InputStream implements Closeable {

private static final int SKIP_BUFFER_SIZE = 2048; //用于skip方法，和skipBuffer相关

private static byte[] skipBuffer; // skipBuffer is initialized in skip(long), if needed.

public abstract int read() throws IOException; //从输入流中读取下一个字节，

//正常返回0-255，到达文件的末尾返回-1

//在流中还有数据，但是没有读到时该方法会阻塞（block）

//Java IO和New IO的区别就是阻塞流和非阻塞流

//抽象方法哦！不同的子类不同的实现哦！

//将流中的数据读入放在byte数组的第off个位置先后的len个位置中

//放回值为放入字节的个数。

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; } //到达文件的末端返回-1

b[off] = (byte)c; //放回的字节downcast

int i = 1; //已经读取了一个字节

try {

for (; i < len ; i++) { //最多读取len个字节，所以要循环len次

c = read(); //每次循环从流中读取一个字节

//由于read方法阻塞，

//所以read(byte[],int,int)也会阻塞

if (c == -1) { break; } //到达末尾，理所当然放回-1

b[off + i] = (byte)c; //读到就放入byte数组中

}

} catch (IOException ee) { }

return i;

//上面这个部分其实还有一点比较重要，int i = 1;在循环的外围，或许你经常见到，

//或许你只会在循环是才声明，为什么呢？

//声明在外面，增大了变量的生存周期（在循环外面），所以后面可以return返回

//极其一般的想法。在类成员变量生命周期中使用同样的理念。

//在软件设计中，类和类的关系中也是一样的。

} //这个方法在利用抽象方法read，某种意义上简单的Templete模式。

public int read(byte b[]) throws IOException {

return read(b, 0, b.length);

} //利用上面的方法read(byte[] b)

public long skip(long n) throws IOException {

long remaining = n; //方法内部使用的、表示要跳过的字节数目，

//使用它完成一系列字节读取的循环

int nr;

if (skipBuffer == null)

skipBuffer = new byte[SKIP_BUFFER_SIZE]; //初始化一个跳转的缓存

byte[] localSkipBuffer = skipBuffer; //本地化的跳转缓存

if (n <= 0) { return 0; } //检查输入参数，应该放在方法的开始

while (remaining > 0) { //一共要跳过n个，每次跳过部分，循环

nr = read(localSkipBuffer, 0, (int) Math.min(SKIP_BUFFER_SIZE, remaining));

//利用上面的read(byte[],int,int)方法尽量读取n个字节

if (nr < 0) { break; } //读到流的末端，则返回

remaining -= nr; //没有完全读到需要的，则继续循环

}

return n - remaining;//返回时要么全部读完，要么因为到达文件末端，读取了部分

}

public int available() throws IOException { //查询流中还有多少可以读取的字节

return 0;

}

//该方法不会block。在java中抽象类方法的实现一般有以下几种方式：

//1.抛出异常（java.util）；2.“弱”实现。象上面这种。子类在必要的时候覆盖它。

//3.“空”实现。下面有例子。

public void close() throws IOException {}

//关闭当前流、同时释放与此流相关的资源

public synchronized void mark(int readlimit) {}

//在当前位置对流进行标记，必要的时候可以使用reset方法返回。

//markSupport可以查询当前流是否支持mark

public synchronized void reset() throws IOException {

throw new IOException("mark/reset not supported");

}

//对mark过的流进行复位。只有当流支持mark时才可以使用此方法。

//看看mark、available和reset方法。体会为什么？！

public boolean markSupported() { //查询是否支持mark

return false;

} //绝大部分不支持，因此提供默认实现，返回false。子类有需要可以覆盖。

}

2 FilterInputStream

这是字节输入流部分装饰器模式的核心。是我们在装饰器模式中的Decorator对象，主要完成对其它流装饰的基本功能。下面是它的源代码:

package java.io;

//该类对被装饰的流进行基本的包裹。不增加额外的功能。

//客户在需要的时候可以覆盖相应的方法。具体覆盖可以在ByteInputStream中看到！

public class FilterInputStream extends InputStream {

protected volatile InputStream in; //将要被装饰的字节输入流

protected FilterInputStream(InputStream in) { //通过构造方法传入此被装饰的流

this.in = in;

}

//装饰器的代码特征：被装饰的对象一般是装饰器的成员变量

//上面几行可以看出。

//下面这些方法，完成最小的装饰――0装饰，只是调用被装饰流的方法而已

public int read() throws IOException {

return in.read();

}

public int read(byte b[]) throws IOException {

return read(b, 0, b.length);

}

public int read(byte b[], int off, int len) throws IOException {

return in.read(b, off, len);

}

public long skip(long n) throws IOException {

return in.skip(n);

}

public int available() throws IOException {

return in.available();

}

public void close() throws IOException {

in.close();

}

public synchronized void mark(int readlimit) {

in.mark(readlimit);

}

public synchronized void reset() throws IOException {

in.reset();

}

public boolean markSupported() {

return in.markSupported();

}

//以上的方法，都是通过调用被装饰对象in完成的。没有添加任何额外功能

//装饰器模式中的Decorator对象，不增加被装饰对象的功能。

//它是装饰器模式中的核心。更多关于装饰器模式的理论请阅读博客中的文章。

}

以上分析了所有字节输入流的公共父类InputStream和装饰器类FilterInputStream类。他们是装饰器模式中两个重要的类。更多细节请阅读博客中装饰器模式的文章。下面将讲解一个具体的流ByteArrayInputStream，不过它是采用适配器设计模式。

3 ByteArray到ByteArrayInputStream的适配

// ByteArrayInputStream内部有一个byte类型的buffer。

//很典型的适配器模式的应用――将byte数组适配流的接口。

//下面是源代码分析：

package java.io;

public class ByteArrayInputStream extends InputStream {

protected byte buf[]; //内部的buffer，一般通过构造器输入

protected int pos; //当前位置的cursor。从0至byte数组的长度。

//byte[pos]就是read方法读取的字节

protected int mark = 0; //mark的位置。

protected int count; //流中字节的数目。不一定与byte[]的长度一致？？？

public ByteArrayInputStream(byte buf[]) {//从一个byte[]创建一个ByteArrayInputStream

this.buf = buf; //初始化流中的各个成员变量

this.pos = 0;

this.count = buf.length; //count就等于buf.length

}

public ByteArrayInputStream(byte buf[], int offset, int length) { //构造器

this.buf = buf;

this.pos = offset; //与上面不同

this.count = Math.min(offset + length, buf.length);

this.mark = offset; //与上面不同

}

public synchronized int read() { //从流中读取下一个字节

return (pos < count) ? (buf[pos++] & 0xff) : -1; //返回下一个位置的字节

//流中没有数据则返回-1

}

//下面这个方法很有意思！从InputStream中可以看出其提供了该方法的实现。

//为什么ByteArrayInputStream要覆盖此方法呢？

//同样的我们在Java Collections Framework中可以看到：

//AbstractCollection利用iterator实现了Collecion接口的很多方法。但是，

//在ArrayList中却有很多被子类覆盖了。为什么如此呢？？

public synchronized int read(byte b[], int off, int len) {

if (b == null) { //首先检查输入参数的状态是否正确

throw new NullPointerException();

} else if (off < 0 || len < 0 || len > b.length - off) {

throw new IndexOutOfBoundsException();

}

if (pos >= count) { return -1; }

if (pos + len > count) { len = count - pos; }

if (len <= 0) { return 0; }

System.arraycopy(buf, pos, b, off, len); //java中提供数据复制的方法

pos += len;

return len;

}

//出于速度的原因！他们都用到System.arraycopy方法。想想为什么？

//某些时候，父类不能完全实现子类的功能，父类的实现一般比较通用。

//当子类有更有效的方法时，我们会覆盖这些方法。这样可是不太OO的哦！

//下面这个方法，在InputStream中也已经实现了。

//但是当时是通过将字节读入一个buffer中实现的，好像效率低了一点。

//看看下面这段代码，是否极其简单呢？！

public synchronized long skip(long n) {

if (pos + n > count) { n = count - pos; } //当前位置，可以跳跃的字节数目

if (n < 0) { return 0; } //小于0，则不可以跳跃

pos += n; //跳跃后，当前位置变化

return n;

} //比InputStream中的方法简单、高效吧！

public synchronized int available() {

return count - pos;

}

//查询流中还有多少字节没有读取。

//在我们的ByteArrayInputStream中就是当前位置以后字节的数目。

public boolean markSupported() {

return true;

} //ByteArrayInputStream支持mark所以返回true

public void mark(int readAheadLimit) {

mark = pos;

}

//在流中当前位置mark。

//在我们的ByteArrayInputStream中就是将当前位置赋给mark变量。

//读取流中的字节就是读取字节数组中当前位置向后的的字节。

public synchronized void reset() {

pos = mark;

}

//重置流。即回到mark的位置。

public void close() throws IOException { }

//关闭ByteArrayInputStream不会产生任何动作。为什么？仔细考虑吧！！

}

上面我们分3小节讲了装饰器模式中的公共父类（对应于输入字节流的InputStream）、Decorator（对应于输入字节流的FilterInputStream）和基本被装饰对象（对应于输入字节流的媒体字节流）。下面我们就要讲述装饰器模式中的具体的包装器（对应于输入字节流的包装器流）。

4 BufferedInputStream

4.1原理及其在软件硬件中的应用

1.read――read(byte[] ,int , int)

2.BufferedInputStream

3.《由一个简单的程序谈起》

4. Cache

5.Pool

6.Spling Printer

（最近比较忙，不讲了！）

4.2 BufferedInputStream源代码分析

package java.io;

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

//该类主要完成对被包装流，加上一个缓存的功能

public class BufferedInputStream extends FilterInputStream {

private static int defaultBufferSize = 8192; //默认缓存的大小

protected volatile byte buf[]; //内部的缓存

protected int count; //buffer的大小

protected int pos; //buffer中cursor的位置

protected int markpos = -1; //mark的位置

protected int marklimit; //mark的范围

//原子性更新。和一致性编程相关

private static final

AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater =

AtomicReferenceFieldUpdater.newUpdater (BufferedInputStream.class, byte[].class, "buf");

private InputStream getInIfOpen() throws IOException { //检查输入流是否关闭，同时返回被包装流

InputStream input = in;

if (input == null) throw new IOException("Stream closed");

return input;

}

private byte[] getBufIfOpen() throws IOException { //检查buffer的状态，同时返回缓存

byte[] buffer = buf;

if (buffer == null) throw new IOException("Stream closed"); //不太可能发生的状态

return buffer;

}

public BufferedInputStream(InputStream in) { //构造器

this(in, defaultBufferSize); //指定默认长度的buffer

}

public BufferedInputStream(InputStream in, int size) { //构造器

super(in);

if (size <= 0) { //检查输入参数

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

}

buf = new byte[size]; //创建指定长度的buffer

}

//从流中读取数据，填充如缓存中。

private void fill() throws IOException {

byte[] buffer = getBufIfOpen(); //得到buffer

if (markpos < 0)

pos = 0; //mark位置小于0，此时pos为0

else if (pos >= buffer.length) //pos大于buffer的长度

if (markpos > 0) {

int sz = pos - markpos; //

System.arraycopy(buffer, markpos, buffer, 0, sz);

pos = sz;

markpos = 0;

} else if (buffer.length >= marklimit) { //buffer的长度大于marklimit时，mark失效

markpos = -1; //

pos = 0; //丢弃buffer中的内容

} else { //buffer的长度小于marklimit时对buffer扩容

int nsz = pos * 2;

if (nsz > marklimit) nsz = marklimit;//扩容为原来的2倍，太大则为marklimit大小

byte nbuf[] = new byte[nsz];

System.arraycopy(buffer, 0, nbuf, 0, pos); //将buffer中的字节拷贝如扩容后的buf中

if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {

//在buffer在被操作时，不能取代此buffer

throw new IOException("Stream closed");

}

buffer = nbuf; //将新buf赋值给buffer

}

count = pos;

int n = getInIfOpen().read(buffer, pos, buffer.length - pos);

if (n > 0) count = n + pos;

}

public synchronized int read() throws IOException { //读取下一个字节

if (pos >= count) { //到达buffer的末端

fill(); //就从流中读取数据，填充buffer

if (pos >= count) return -1; //读过一次，没有数据则返回-1

}

return getBufIfOpen()[pos++] & 0xff; //返回buffer中下一个位置的字节

}

private int read1(byte[] b, int off, int len) throws IOException { //将数据从流中读入buffer中

int avail = count - pos; //buffer中还剩的可读字符

if (avail <= 0) { //buffer中没有可以读取的数据时

if (len >= getBufIfOpen().length && markpos < 0) { //将输入流中的字节读入b中

return getInIfOpen().read(b, off, len);

}

fill(); //填充

avail = count - pos;

if (avail <= 0) return -1;

}

int cnt = (avail < len) ? avail : len; //从流中读取后，检查可以读取的数目

System.arraycopy(getBufIfOpen(), pos, b, off, cnt); //将当前buffer中的字节放入b的末端

pos += cnt;

return cnt;

}

public synchronized int read(byte b[], int off, int len)throws IOException {

getBufIfOpen(); // 检查buffer是否open

if ((off | len | (off + len) | (b.length - (off + len))) < 0) { //检查输入参数是否正确

throw new IndexOutOfBoundsException();

} else if (len == 0) {

return 0;

}

int n = 0;

for (;;) {

int nread = read1(b, off + n, len - n);

if (nread <= 0) return (n == 0) ? nread : n;

n += nread;

if (n >= len) return n;

// if not closed but no bytes available, return

InputStream input = in;

if (input != null && input.available() <= 0) return n;

}

public synchronized long skip(long n) throws IOException {

getBufIfOpen(); // 检查buffer是否关闭

if (n <= 0) { return 0; } //检查输入参数是否正确

long avail = count - pos; //buffered中可以读取字节的数目

if (avail <= 0) { //可以读取的小于0，则从流中读取

if (markpos <0) return getInIfOpen().skip(n); //mark小于0，则mark在流中

fill(); // 从流中读取数据，填充缓冲区。

avail = count - pos; //可以读的取字节为buffer的容量减当前位置

if (avail <= 0) return 0;

}

long skipped = (avail < n) ? avail : n;

pos += skipped; //当前位置改变

return skipped;

}

public synchronized int available() throws IOException {

return getInIfOpen().available() + (count - pos);

}

//该方法不会block！返回流中可以读取的字节的数目。

//该方法的返回值为缓存中的可读字节数目加流中可读字节数目的和

public synchronized void mark(int readlimit) { //当前位置处为mark位置

marklimit = readlimit;

markpos = pos;

}

public synchronized void reset() throws IOException {

getBufIfOpen(); // 缓冲去关闭了，肯定就抛出异常！程序设计中经常的手段

if (markpos < 0) throw new IOException("Resetting to invalid mark");

pos = markpos;

}

public boolean markSupported() { //该流和ByteArrayInputStream一样都支持mark

return true;

}

//关闭当前流同时释放相应的系统资源。

public void close() throws IOException {

byte[] buffer;

while ( (buffer = buf) != null) {

if (bufUpdater.compareAndSet(this, buffer, null)) {

InputStream input = in;

in = null;

if (input != null) input.close();

return;

}

// Else retry in case a new buf was CASed in fill()

}

从PipedInputStream/PipedOutputStream谈起

江苏无锡缪小东

本篇主要从分析PipeInputStrem和PipedOutputStream谈起。谈及软件设计的变化，以及如何将软件拆分、组合，适配……

1 源代码分析

下面将详细分析PipedInputStream和PipedOutputStream的源代码。

1.1 PipedInputStream

package java.io;

//PipedInputStream必须和PipedOutputStream联合使用。即必须连接输入部分。

//其原理为：PipedInputStream内部有一个Buffer，

//PipedInputStream可以使用InputStream的方法读取其Buffer中的字节。

//PipedInputStream中Buffer中的字节是PipedOutputStream调用PipedInputStream的方法放入的。

public class PipedInputStream extends InputStream {

boolean closedByWriter = false; //标识有读取方或写入方关闭

volatile boolean closedByReader = false;

boolean connected = false; //是否建立连接

Thread readSide; //标识哪个线程

Thread writeSide;

protected static final int PIPE_SIZE = 1024; //缓冲区的默认大小

protected byte buffer[] = new byte[PIPE_SIZE]; //缓冲区

protected int in = -1; //下一个写入字节的位置。0代表空，in==out代表满

protected int out = 0; //下一个读取字节的位置

public PipedInputStream(PipedOutputStream src) throws IOException { //给定源的输入流

connect(src);

}

public PipedInputStream() { } //默认构造器，下部一定要connect源

public void connect(PipedOutputStream src) throws IOException { //连接输入源

src.connect(this); //调用源的connect方法连接当前对象

}

protected synchronized void receive(int b) throws IOException { //只被PipedOuputStream调用

checkStateForReceive(); //检查状态，写入

writeSide = Thread.currentThread(); //永远是PipedOuputStream

if (in == out) awaitSpace(); //输入和输出相等，等待空间

if (in < 0) {

in = 0;

out = 0;

}

buffer[in++] = (byte)(b & 0xFF); //放入buffer相应的位置

if (in >= buffer.length) { in = 0; } //in为0表示buffer已空

}

synchronized void receive(byte b[], int off, int len) throws IOException {

checkStateForReceive();

writeSide = Thread.currentThread(); //从PipedOutputStream可以看出

int bytesToTransfer = len;

while (bytesToTransfer > 0) {

if (in == out) awaitSpace(); //满了，会通知读取的；空会通知写入

int nextTransferAmount = 0;

if (out < in) {

nextTransferAmount = buffer.length - in;

} else if (in < out) {

if (in == -1) {

in = out = 0;

nextTransferAmount = buffer.length - in;

} else {

nextTransferAmount = out - in;

}

if (nextTransferAmount > bytesToTransfer) nextTransferAmount = bytesToTransfer;

assert(nextTransferAmount > 0);

System.arraycopy(b, off, buffer, in, nextTransferAmount);

bytesToTransfer -= nextTransferAmount;

off += nextTransferAmount;

in += nextTransferAmount;

if (in >= buffer.length) { in = 0; }

}

private void checkStateForReceive() throws IOException { //检查当前状态，等待输入

if (!connected) {

throw new IOException("Pipe not connected");

} else if (closedByWriter || closedByReader) {

throw new IOException("Pipe closed");

} else if (readSide != null && !readSide.isAlive()) {

throw new IOException("Read end dead");

}

private void awaitSpace() throws IOException { //Buffer已满，等待一段时间

while (in == out) { //in==out表示满了，没有空间

checkStateForReceive(); //检查接受端的状态

notifyAll(); //通知读取端

try {

wait(1000);

} catch (InterruptedException ex) {

throw new java.io.InterruptedIOException();

}

synchronized void receivedLast() { //通知所有等待的线程（）已经接受到最后的字节

closedByWriter = true; //

notifyAll();

}

public synchronized int read() throws IOException {

if (!connected) { //检查一些内部状态

throw new IOException("Pipe not connected");

} else if (closedByReader) {

throw new IOException("Pipe closed");

} else if (writeSide != null && !writeSide.isAlive()&& !closedByWriter && (in < 0)) {

throw new IOException("Write end dead");

}

readSide = Thread.currentThread(); //当前线程读取

int trials = 2; //重复两次？？？？

while (in < 0) {

if (closedByWriter) { return -1; } //输入断关闭返回-1

if ((writeSide != null) && (!writeSide.isAlive()) && (--trials < 0)) { //状态错误

throw new IOException("Pipe broken");

}

notifyAll(); // 空了，通知写入端可以写入

try {

wait(1000);

} catch (InterruptedException ex) {

throw new java.io.InterruptedIOException();

}

int ret = buffer[out++] & 0xFF; //

if (out >= buffer.length) { out = 0; }

if (in == out) { in = -1; } //没有任何字节

return ret;

}

public synchronized 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 < 0) { return -1; } //已经到达末尾了，返回-1

b[off] = (byte) c; //放入外部buffer中

int rlen = 1; //return-len

while ((in >= 0) && (--len > 0)) { //下一个in存在，且没有到达len

b[off + rlen] = buffer[out++]; //依次放入外部buffer

rlen++;

if (out >= buffer.length) { out = 0; } //读到buffer的末尾，返回头部

if (in == out) { in = -1; } //读、写位置一致时，表示没有数据

}

return rlen; //返回填充的长度

}

public synchronized int available() throws IOException { //返回还有多少字节可以读取

if(in < 0)

return 0; //到达末端，没有字节

else if(in == out)

return buffer.length; //写入的和读出的一致，表示满

else if (in > out)

return in - out; //写入的大于读出

else

return in + buffer.length - out; //写入的小于读出的

}

public void close() throws IOException { //关闭当前流，同时释放与其相关的资源

closedByReader = true; //表示由输入流关闭

synchronized (this) { in = -1; } //同步化当前对象，in为-1

}

1.2 PipedOutputStream

// PipedOutputStream一般必须和一个PipedInputStream连接。共同构成一个pipe。

//它们的职能是：

package java.io;

import java.io.*;

public class PipedOutputStream extends OutputStream {

private PipedInputStream sink; //包含一个PipedInputStream

public PipedOutputStream(PipedInputStream snk)throws IOException { //带有目的地的构造器

connect(snk);

}

public PipedOutputStream() { } //默认构造器，必须使用下面的connect方法连接

public synchronized void connect(PipedInputStream snk) throws IOException {

if (snk == null) { //检查输入参数的正确性

throw new NullPointerException();

} else if (sink != null || snk.connected) {

throw new IOException("Already connected");

}

sink = snk; //一系列初始化工作

snk.in = -1;

snk.out = 0;

snk.connected = true;

}

public void write(int b) throws IOException { //向流中写入数据

if (sink == null) { throw new IOException("Pipe not connected"); }

sink.receive(b); //本质上是，调用PipedInputStream的receive方法接受此字节

}

public void write(byte b[], int off, int len) throws IOException {

if (sink == null) { //首先检查输入参数的正确性

throw new IOException("Pipe not connected");

} else if (b == null) {

throw new NullPointerException();

} else if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0)) {

throw new IndexOutOfBoundsException();

} else if (len == 0) {

return;

}

sink.receive(b, off, len); //调用PipedInputStream的receive方法接受

}

public synchronized void flush() throws IOException { //flush输出流

if (sink != null) {

synchronized (sink) { sink.notifyAll(); } //本质是通知输入流，可以读取

}

public void close() throws IOException { //关闭流同时释放相关资源

if (sink != null) { sink.receivedLast(); }

}

2 Buffer的状态

上图是PipedInputStream中缓存的状态图。在程序中我们利用了byte数组，循环地向其中写入数据，写入有一个cursor（in），读出也有一个cursor（out）。上图表示in和out不同位置时，buffer中的各个位置的状态。蓝色的代表可以读取的字节。白色的表示此位置没有字节，或者此位置已经被PipedInputStream读取了。

3 交互简图

下图是从源代码部分转换过来的关于PipedInputStream和PipedOutputStream的交互图。

从图中可以看出：

1. 整个PipedInputStream是这对管道的核心。管道本身是一个byte的数组。

2. PipedOutputStream对象通过Delegate方法复用PipedInputStream，同时屏蔽了其中的读取的方法，我们仅仅可以构造PipedOutputStream对象。（从这一点可以看出Delegate复用比继承复用的优越性了！）从设计模式的角度更象Adapter――PipedInputStream本身提供读取和写入的功能，将写入的功能适配到OutputStream，就成为一个PipedOutputStream。这样就形成一个类，适配后形成两种功能的类。

3. 调用PipedOutputStream的连接方法实际就是调用PipedInputStream的连接方法。

4. 调用PipedOutputStream的写相关的方法实际就是调用PipedInputStream的对应方法。

以上也是一种适配，将管道的概念适配到流的概念，同时将两者的职能分开。

4 将Chanel放入PipedOutputStream

上面的例子中，Chanel放在PipedInputStream中，我们仔细思考后可以顺理成章地将其Chanel放入PipedOutputStream中。请注意synchronized方法是得到哪个字节流的锁！！

5 Chanel移出的一个例子

在上面两个例子中Buffer要么在写入对象的内部，要么在读取对象的内部。主要通过适配该对象的方法，达到自己的需求而已。下面是一个一般的例子――将Chanel移出，Chanel提供了写入与读取的功能。这也完全合乎OO的“Single Responsibility Protocol――SRP”。输入部分使用Delegate复用此Chanel，将其适配至InputStream和OutputStream。下面是简单的Source code。

//PipedChanel.java

import java.io.IOException ;

public class PipedChanel {

protected static final int PIPE_SIZE = 1024;

protected byte buffer[] = new byte[PIPE_SIZE];

protected int in = -1;

protected int out = 0;

public PipedChanel(){ }

public PipedChanel(int size){

buffer = new byte[size] ;

}

public synchronized int read() throws IOException { }

public synchronized int read(byte b[], int off, int len) throws IOException { }

public synchronized int available() throws IOException {}

public synchronized void close() throws IOException {}

public synchronized void write(int b) throws IOException {}

public synchronized void write(byte b[]) throws IOException {}

public synchronized void write(byte b[], int off, int len) throws IOException {}

public synchronized void flush() throws IOException {}

public void waitWhileFull(){ } //当Chanel已经满了，写线程等待

public void waitWhileEmpty{ } //当Chanel为空，读取线程等待

//以上是两个操作Chanel时的状态相关的方法。

//是一致性编程部分，典型的设计模式。

//这两个方法，包含在对应读或写方法的最前面。

}

// PipedChanelInputStream.java

import java.io.*;

public class PipedChanelInputStream extends InputStream {

private PipedChanel chanel ;

public PipedChanelInputStream(PipedChanel chanel){

this.chanel = chanel ;

}

public int read() throws IOException {

return chanel.read();

}

public int read(byte b[], int off, int len) throws IOException {

return chanel.read(b,off,len);

}

public int available() throws IOException {

return chanel.available();

}

public void close() throws IOException {

chanel.close();

}

// PipedChanelOutputStream.java

import java.io.*;

public class PipedChanelOutputStream extends OutputStream {

private PipedChanel chanel ;

public PipedChanelOutputStream(PipedChanel chanel){

this.chanel = chanel ;

}

public synchronized void write(int b) throws IOException {

chanel.write(b);

}

public synchronized void write(byte b[]) throws IOException {

chanel.write(b);

}

public synchronized void write(byte b[], int off, int len) throws IOException {

chanel.write(b,off,len);

}

public synchronized void flush() throws IOException {

chanel.flush();

}

public synchronized void close() throws IOException {

chanel.close();

}

很简单的例子。我们可以体会适配器模式，可以体会软件设计的灵活性……

上面的关于PipedInputStream和PipedOutputStream的例子，本质上是对一个Chanel的几个不同的适配。Chanel作为一种编程模式，在软件设计中有极其广泛的应用。下面一节是JMS的简洁阐述！

以上的例子其实是一个典型的使用适配器。

6 JMS的架构

JMS为J2EE部分的面向消息中间件的API。JMS的Queue、Topic某种意义上就是我们上面Chanel移到网络的其它一段――服务器上的一个例子。同时该Chanel得到了很多强化。如：1.支持交易；2.支持持久化……

在J2EE中JMS是一个比较重要的方向，大型的企业应用中都会使用。不过J2EE中给出了其API，背后的理念还是相当丰富的！（具体细节以后会有相关文章！！唉，还是因为忙！！）

类	功能	如何构造
		怎样使用
ByteArrayInputStream	将内存中的Byte数组适配为一个InputStream。	从内存中的Byte数组创建该对象（2种方法）
		一般作为数据源，会使用其它装饰流提供额外的功能，一般都建议加个缓冲功能。
StringBufferInputStream	将内存中的字符串适配为一个InputStream。	从一个String对象创建该对象。底层的实现使用StringBuffer。该类被Deprecated。主要原因是StringBuffer不应该属于字节流，所以推荐使用StringReader。
		一般作为数据源，同样会使用其它装饰器提供额外的功能。
FileInputStream	最基本的文件输入流。主要用于从文件中读取信息。	通过一个代表文件路径的 String、File对象或者 FileDescriptor对象创建。
		一般作为数据源，同样会使用其它装饰器提供额外的功能。
PipedInputStream	读取从对应PipedOutputStream写入的数据。在流中实现了管道的概念。	利用对应的PipedOutputStream创建。
		在多线程程序中作为数据源，同样会使用其它装饰器提供额外的功能。
SequenceInputStream	将2个或者多个InputStream 对象转变为一个InputStream.	使用两个InputStream 或者内部对象为InputStream 的Enumeration对象创建该对象。
		一般作为数据源，同样会使用其它装饰器提供额外的功能。
FilterInputStream	给其它被装饰对象提供额外功能的抽象类	主要子类见下表

类	功能	如何构造
		怎样使用
DataInputStream	一般和DataOutputStream配对使用,完成基本数据类型的读写。	利用一个InputStream构造。
		提供了大量的读取基本数据类新的读取方法。
BufferedInputStream	使用该对象阻止每次读取一个字节都会频繁操作IO。将字节读取一个缓存区，从缓存区读取。	利用一个InputStream、或者带上一个自定义的缓存区的大小构造。
		使用InputStream的方法读取，只是背后多一个缓存的功能。设计模式中透明装饰器的应用。
LineNumberInputStream	跟踪输入流中的行号。可以调用getLineNumber( )和 setLineNumber(int)方法得到和设置行号。	利用一个InputStream构造。
		紧紧增加一个行号。可以象使用其它InputStream一样使用。
PushbackInputStream	可以在读取最后一个byte 后将其放回到缓存中。	利用一个InputStream构造。
		一般仅仅会在设计compiler的scanner 时会用到这个类。在我们的java语言的编译器中使用它。很多程序员可能一辈子都不需要。

类	功能	如何构造
		怎样使用
ByteArrayOutputStream	在内存中创建一个buffer。所有写入此流中的数据都被放入到此buffer中。	无参或者使用一个可选的初始化buffer的大小的参数构造。
		一般将其和FilterOutputStream套接得到额外的功能。建议首先和BufferedOutputStream套接实现缓冲功能。通过toByteArray方法可以得到流中的数据。（不通明装饰器的用法）
FileOutputStream	将信息写入文件中。	使用代表文件路径的String、File对象或者 FileDescriptor对象创建。还可以加一个代表写入的方式是否为append的标记。
		一般将其和FilterOutputStream套接得到额外的功能。
PipedOutputStream	任何写入此对象的信息都被放入对应PipedInputStream 对象的缓存中，从而完成线程的通信，实现了“管道”的概念。具体在后面详细讲解。	利用PipedInputStream构造
		在多线程程序中数据的目的地的。一般将其和FilterOutputStream套接得到额外的功能。
FilterOutputStream	实现装饰器功能的抽象类。为其它OutputStream对象增加额外的功能。	见下表
		见下表

类	功能	如何构造
		怎样使用
DataOutputStream	通常和DataInputStream配合使用，使用它可以写入基本数据类新。	使用OutputStream构造
		包含大量的写入基本数据类型的方法。
PrintStream	产生具有格式的输出信息。（一般地在java程序中DataOutputStream用于数据的存储，即J2EE中持久层完成的功能，PrintStream完成显示的功能，类似于J2EE中表现层的功能）	使用OutputStream和一个可选的表示缓存是否在每次换行时是否flush的标记构造。还提供很多和文件相关的构造方法。
		一般是一个终极（“final”）的包装器，很多时候我们都使用它！
BufferedOutputStream	使用它可以避免频繁地向IO写入数据，数据一般都写入一个缓存区，在调用flush方法后会清空缓存、一次完成数据的写入。	从一个OutputStream或者和一个代表缓存区大小的可选参数构造。
		提供和其它OutputStream一致的接口，只是内部提供一个缓存的功能。

静以修身！

Java IO

3.4 字节流与字符流

3.5 IO中的输入字符流

3.6 IO中的输出字符流

3.7字符流的输入与输出的对应

3.8字节流和字符流的对应

3.8.1输入的对应

3.8.2输出的对应

从InputStream到ByteArrayInputStream

1 InputStream

2 FilterInputStream

3 ByteArray到ByteArrayInputStream的适配

4 BufferedInputStream

4.1原理及其在软件硬件中的应用

4.2 BufferedInputStream源代码分析

从PipedInputStream/PipedOutputStream谈起

1 源代码分析

1.1 PipedInputStream

1.2 PipedOutputStream

2 Buffer的状态

3 交互简图

4 将Chanel放入PipedOutputStream

5 Chanel移出的一个例子

6 JMS的架构

导航

公告