从设计者的角度理解Java IO流

2017-02-08 16:28
283

摘要

Java I/O是Java技术体系中非常基础的部分,它是学习Java NIO的基础。而深入理解Java NIO则是学习现代高性能网络通信框架(比如Netty)的基础。本文试图从设计者的角度去理解Java I/O流,从Java I/O的最初概念输入流/输出流开始,通过使用面向对象的各种扩展技术(继承、设计模式等等)逐渐展开对整个Java I/O的介绍,最后通过介绍第三方开源框架对Java I/O的扩展来结束本文。通过阅读本文,希望大家可以对整个Java I/O体系有一个整体的认识,可以从概念上而不是细节上对Java I/O的技术体系进行推导,知道Java I/O是什么,又能进一步知道为什么是这样而不是其他什么样。本文不会涉及具体的代码细节,如果对Java I/O体系的代码细节感兴趣,可以阅读JDK源代码。

1、基本概念

任何软件框架或者技术体系,回归到最初,一定有几个最基本的概念在支撑它的发展。Java I/O最基本的概念就是输入流和输出流,也就是InputStream和OutputStream。

从设计者的角度理解Java IO流-JEESNS

InputStream

最基本的字节输入流,抽象类,定义了读取原始字节的所有基本方法

1.1.1、public abstract int read()   读取一个字节的方法,最基础的方法

1.1.2、public int read(byte b[], int off, int len) 读取指定长度的字节到字节数组,基于方法1.1.1

1.1.3、public int read(byte b[])    读取一个数组那么多的字节,基于 方法1.1.2

1.1.4、public long skip(long n)   跳过一定字节数,用到的比较少

1.1.5、public int available()   返回可以读取的最少字节数,用到的比较少

1.1.6、mark(int readlimit)、void reset()和markSupported()这三个方法,并不是每个子类都支持,这里设计得不合理,完全可以把这三个方法迁移到一个新的接口中去。

1.1.7、public void close() 关闭输入流

OutputStream

最基本的字节输出流,抽象类,定义了写入原始字节的所有基本方法

1.2.1、public abstract void write(int b) 写入一个字节,最基础的方法

1.2.2、public void write(byte b[], int off, int len)将一个字节数组中的部分字节写入,基于基本方法1.2.1

1.2.3、public void write(byte b[])  将一个字节数组写入,基于方法1.2.2

1.2.4、public void close() 关闭输出流

1.2.5、public void flush() 刷新输出流,由于操作系统会存在写入缓冲机制,也就是说,当我们调用write的时候,一般操作系统会把我们要写入的字节缓冲到缓冲区,然后在某个时间点一起刷新到本地磁盘,如果我们想要强制刷新,则需要调用这个方法。

小结

InputStream和OutputStream定义了I/O领域最基础的行为,也就是读取和写入一个字节,同时使用了模板方法将读取和写入的行为进行了适当扩展。

2、扩展点一:对I/O流的继承

InputStream和OutputStream都是抽象类,它们仅仅定义了I/O领域最基础的方法,但不涉及具体实现。针对不同的数据来源,InputStream和OutputStream存在三种实现:一种是基于内存的ByteArrayInputStream/ByteArrayOutputStream,一种是基于磁盘文件的FileInputStream/FileOutputStream,还有一种是基于网络的SocketInputStream/SocketOutputStream。

从设计者的角度理解Java IO流-JEESNS

FileInputStream/FileOutputStream

读取写入的源是操作系统的文件FileInputStream使用native方法进行底层文件的读取

private native int read0() 

所有其他的read方法最终都是基于这个本地方法实现。

FileOutputStream使用native方法进行底层文件的写入

private native void writeBytes(byte b[], int off, int len, boolean append)

所有其他的write方法都是基于这个本地方法实现。

ByteArrayInputStream/ByteArrayOutputStream

读取写入的源是内存的一个数组,用的比较少。

SocketInputStream/SocketOutputStream

SocketInputStream使用 private native int socketRead0(FileDescriptor fd,byte b[], int off, int len,int timeout)这个native方法读取远程服务器的数据流。所有read方法都是基于这个本地方法实现的。 SocketOutputStream 使用private native void socketWrite0(FileDescriptor fd, byte[] b, int off,int len)这个native方法来进行远程数据流的写入,所有的write方法都是基于这个方法实现的。

小结

InputStream和OutputStream是对流的抽象,不同的具体流通过继承去实现,对于Java本地平台,最基本的就是基于文件系统的流,当涉及到远程系统,就会出现网络流,基于内存的流一般不会用到。

3、扩展点二:对IO流行为的扩展

装饰模式可以对一个类的行为进行扩展,并且不改变它的接口,Java通过FilterInputStream/FilterOutputStream实现了装饰模式。


从设计者的角度理解Java IO流-JEESNS

责任链模式则是定义统一的接口,然后通过多个实现该接口的子类串行协作完成一项复杂的功能。Java通过将多个FilterInputStream/FilterOutputStream的子类串联起来实现了责任链模式。


从设计者的角度理解Java IO流-JEESNS

FilterInputStream/FilterOutputStream

FilterInputStream本身不实现输入流的功能,而是通过构造函数传入另一个InputStream的子类,把输入流的功能交给它做。通过继承FilterInputStream可以对输入输出流的行为进行扩展,这是装饰模式的典型用法。通过多个装饰类实现责任链模式,它将对一个输入流的不同处理分散到不同的FilterInputStream中去。FilterOutputStream和FilterInputStream的原理一样。

BufferedInputStream/BufferedOutputStream

继承了FilterInputStream,实现了输入流处理中的缓冲的功能。底层的流会先被读取到一个字节数组中,用户使用BufferedInputStream读取数据的时候,会先读取字节数组中的数据,读完了才会调用底层的流进行进一步的读取。这种方法可以提升读取的性能。继承了FilterOutputStream,实现了输出流处理中的缓冲功能。当用户写入数据的时候,其实是先写入到BufferedOutputStream的一个字节数组中,当这个字节数组满了,才会真正调用底层的输出流执行输出动作。这种方法可以提升写入的性能。在使用BufferedOutputStream的写入功能时,一定要使用flush,因为缓冲数组不满的时候是不会写入底层流的,在写入最后一点数据的时候,缓冲数据不一定被填满,这时候就需要调用flush进行强制刷新。

PrintStream

继承FilterOutputStream,这个类的print和println方法可以把java的一些基本类型数据转换成字节写入到底层输出流,但是PrintStream对String的转换是平台相关的,不同的平台会有不同的编码,所以写入到底层的字节也不同,因此PrintStream只适合于测试输出,不适合于一般的I/O操作,特别是网络流。

DataInputStream/DataOutputStream

这两个类继承了FilterInputStream/FilterOutputStream,用来实现将java基本类型转换成二进制来进行读写操作,这两个类的readUTF和writeUTF方法使用了一种特殊的UTF编解码方式,只能用于java程序,因此不建议在网络流或者跨平台的应用中使用者两个类

PushbackInputStream

继承了FilterInputStream,提供了一种回退的机制,可以实现unread,本质是使用缓冲数组实现了,也就是说,回退的范围是有限的。

小结

Java I/O设计者通过装饰模式和责任链模式扩展了I/O的行为,实现这种扩展的基石是FilterOutputStream和FilterInputStream。也正是因为这两种设计模式,让我们写的Java I/O代码变成了下面这样的:

InputStream in = new GZIPInputStream(new BufferedInputStream(new FileInputStream("1.txt")));

最里面的FileInputStream是真正的数据来源,而BufferedInputStream和GZIPInputStream都继承了FilterInputStream对I/O的行为进行了改变。

4、Reader/Writer出现的原因

InputStream和OutputStream是面向字节的,而人类的习惯是面向字符,因此InputStream和OutputStream对于程序猿的用户体验不是太好,于是就需要提供一些面向字符的流。由于DataInputStream/DataOutputStream在跨平台的情况下存在问题,因此,java设计者干脆仿照InputStream和OutputStream重新设计了一套面向字符的I/O,也就是Reader/Writer

Reader

基本的字符输入流,是个抽象类

4.1.1、public abstract int read() 读取一个字符的方法,最基础的方法

4.1.2、public int read(char b[], int off, int len) 读取指定长度的字符到字节数组,基于方法4.1.1

4.1.3、public int read(char b[])读取一个数组那么多的字符,基于 方法4.1.2

4.1.4、public long skip(long n) 跳过一定字符,用到的比较少

4.1.5、public int available()  返回可以读取的最少字符,用到的比较少

mark(int readlimit)、void reset()和markSupported()这三个方法,并不是每个子类都支持,这里设计得不合理,完全可以把这三个方法迁移到一个新的接口中去。

4.1.6、public void close() 关闭输入流

4.1.7、public boolean ready() 是否已经准备好

Writer

基本的字符输出流,是个抽象类

4.2.1、abstract public void write(char cbuf[], int off, int len) 抽象方法,用于写入一个字符数组的一部分,需要子类实现

4.2.2、public void write(char cbuf[])  基于4.2.1、,写入一个字符数据

4.2.3、public void write(int c)  将一个int类型的堤16位作为一个字符写入,基于4.2.1

4.2.4、public void write(String str) 写入一个字符串,基于4.2.1

4.2.5、public void write(String str, int off, int len) 写入一个字符串的一部分,基于4.2.1

字符与字节之间的转换

由于计算机只识别字节,所以Reader/Writer的数据来源最终还是字节,而他们无法直接和字节打交道,这时候就需要一个中介者将Reader/Writer和InputStream和OutputStream进行打通,于是就有了InputStreamReader和OutputStreamWriter


从设计者的角度理解Java IO流-JEESNS

5、对Reader/Writer的继承

不同源的Reader/Writer,他们都继承InputStreamReader/OutputStreamWriter

FileReader/FileWriter

继承了InputStreamReader/OutputStreamWriter,传入FileInputStream/FileOutputStream作为底层的字节I/O

CharArrayReader/CharArrayWriter

继承了InputStreamReader/OutputStreamWriter,使用char数组作为数据源,用的比较少

6、对Reader/Writer行为的扩展

类似于字节流,也使用了装饰模式和责任链模式

FilterReader/FilterWriter

对Reader/Writer的代理,底层使用其他Reader/Writer作为真正的操作。

BufferedReader/BufferedWriter

继承了FilterReader/FilterWriter,BufferedReader使用char数组作为数据的缓冲区,读取数据先从缓存区读,读不到在从底层的Reader读,Reader其实用到是更底层的InputStream,尽量不要用BufferedInputStream作为底层InputStream,两层缓冲区没有必要。BufferedWriter先写入缓冲区,待缓冲区写满了再使用底层真正的Writer写,Writer其实用的是更底层的OutputStream。尽量不要用BufferedOutputStream作为底层OutputStream,两层缓冲区没必要。

PushbackReader

继承了FilterReader,实现了可退回的写,本质是使用了一个char数组,所以可退回是有界限。

PrintWriter

用于取代PrintStream,它可以java基本类型转换成字节输出,而且可以正确处理不同字符集的国际化问题。

至此,我们对java.io包下的相关类都做了详细的解读,接下来,让我们看看第三方开源框架都对java IO进行了哪些扩展。

7、开源库对Java IO的扩展

通过上面的解读我们知道,java IO本身的扩展点有两个,一个是通过继承对数据来源的扩展,第二个是通过装饰模式对行为进行扩展。下面介绍的commons-io选择了对行为进行扩展,并提供一些IO操作的工具方法,简化IO操作,而okio则不走寻常路,废弃了java IO的体系,设计出了source/sink接口体系。

commons-io

扩展行为

最新的commons-io 2.5提供了对input和output的各种扩展,通过继承FilterInputStream/FilterOutputStream实现

input:

AutoCloseInputStream:当IO流读到EOF时,会进行自动关闭

BOMInputStream:用于处理含有BOM的输入流,比如Windows下用记事本保存的文件

BoundedInputStream:含有读取界限的输入流,超过这个界限读取将会停止

CountingInputStream:含有统计功能的输入流

DemuxInputStream:这个输入流会将真正的流保存在ThreadLocal中

ProxyInputStream:一个抽象类,提供了读取一个字节之前后之后的回调方法

TaggedInputStream:这个类在抛异常的时候会给异常设置标记,从而用于跟踪异常

TeeInputStream:从一个源读取数据,同时会保存到一个指定的源,类似于unix的tee命令

UnixLineEndingInputStream:这个流在读取换行符的时候会按照unix格式读取

WindowsLineEndingInputStream:这个流在读取换行符的时候会按照Windows格式读取

output

ChunkedOutputStream:写入流的时候按照chunk分批写入

CountingOutputStream:具有统计功能的输出流

DemuxOutputStream:这个输出流会将真正的流保存在ThreadLocal中

ProxyOutputStream:一个抽象类,提供了写入一个字节之前后之后的回调方法

TaggedOutputStream:这个类在抛异常的时候会给异常设置标记,从而用于跟踪异常

TeeOutputStream:写数据到一个源,同时会保存到一个指定的源,类似于unix的tee命令

工具方法IOUtils工具类,主要提供以下工具方法:

closeQuietly - 关闭一个流,忽略异常

toXxx/read - 从某个流读取数据

write - 向某个流写入数据

copy -从一个流复制到另一个流

contentEquals - 比较两个流中的内容

okio

如果使用原生的Java IO进行基本类型的读写,我们需要使用DataInputStream/DataOutputStream以及BufferedReader/BufferedWriter这四个类,除此之外,我们还需要了解InputStreamReader/OutputStreamWriter以及Java IO之间的责任链,对于一般的Java开发者来说,这显然太复杂了。于是okio重新设计了接口Source/Sink,提供了访问基本类型的接口和缓冲功能,同时屏蔽了底层复杂的IO体系,开发者只要传入InputStream和OutputStream就可以了。

具体的类关系如下:


从设计者的角度理解Java IO流-JEESNS

使用Okio的Java代码如下:

try {

BufferedSource bufferedSource = Okio.buffer(Okio.source(new FileInputStream("1.txt")));

int i = bufferedSource.readInt();

long l = bufferedSource.readLong();

String s = bufferedSource.readString(Charset.forName("UTF-8"));

BufferedSink bufferedSink = Okio.buffer(Okio.sink(new FileOutputStream("2.txt")));

bufferedSink.writeInt(1);

bufferedSink.writeLong(2L);

bufferedSink.writeString("123", Charset.forName("UTF-8"));

} catch (Exception e) {

// process exception

}

8、总结

最后我大致来还原一下Java设计者的心路历程:起初通过抽象类InputStream/OutputStream将I/O中的两大基本概念输入流和输出流的行为read/write固定下来,并通过模板方法丰富了read和write这两种最常用的方法。然后自然而然地使用继承去实现这两个抽象类。在计算机世界中最容易想到的输入流和输出流,一个是本地文件,一个是远程网络,当然Java设计者还设计了一个基于内存的流。接下来就是对输入输出流的行为read/write进行扩展,设计者通过装饰模式和责任链模式,在不改变接口的语义的情况下做到了对行为的扩展,于是就有了Java I/O特有的一层套一层的代码写法。当继承和设计模式对I/O进行扩展后,设计者发现,他设计的接口都是面向计算机的,也就是面向字节流的,对于开发者来说这套接口太难用了,开发者需要的是面向字符流的接口,于是他开始修修补补,设计了个DataInputStream/DataOutputStream,但是由于平台兼容性的原因失败了,于是干脆另起炉灶,重新设计了一套类似的接口体系Reader/Writer以及字节流与字符流之间的转换器InputStreamReader/OutputStreamWriter,从而解决了开发者的习惯问题。

帖子评论

关注 / 粉丝

我无话可说