JDK 1.7 java.io 源码学习之FileInputStream和FileOutputStream

文件，应该是开发中较常见的数据源了，故操作文件的字节输入/输出流FileInputStream和FileOutputStream 是 Java IO 字节流中重要的实现类之一。

在说FileInputStream和FileOutputStream之前不得不提一下File类。

File也是java.io 包中的一个类，主要用于描述文件及文件目录路径，具体这里不展开，在FileInputStream和FileOutputStream中主要就是在构造FileInputStream和FileOutputStream时，告知其数据源。

FileInputStream有两个较常见的构造函数：

public FileInputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null);
}

public FileInputStream(File file) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if(security != null) {
security.checkRead(name);
}
if(name == null) {
throw new NullPointerException;
}
if(file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
fd = new FileDescriptor();
fd.incrementAndGetUseCount();
this.path = name;
open(name);
}

从上述两个构造函数大致可以看出，前面一些都是控制和属性赋值相关的语句，核心的就是最后一句open(String name)方法

而且也引出了另一个构造函数：

public FileInputStream(FileDescriptor fdObj) {
SecurityManager security = System.getSecurityManager();
if(fdObj == null) {
throw new NullPointException();
}
if(security != null) {
security.checkRead(fdObj);
}
fd = fdObj;
path = null;
fd.incrementAndGetUseCount();
}

但是open(String name) 其实是一个native方法，由JVM自身实现：

private native void open(String name) throws FileNotFouondException;

最重要的三个方法即InputStream三个read()方法的重写：

public ind read() throws IOException

public ind read() throws IOException {
Object traceContext = IoTrace.fileReadBegin(path);
int b = 0;
try {
b = read0();
} finally {
IoTrace.fileReadEnd(traceContext, b == -1 ? 0 : 1);
}
return b;
}

private native int read0() throws IOException;

实际只是调用了native read0()方法

public int read(byte b[]) throws IOException

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

public int read(byte b[]) throws IOException {
Object traceContext = IoTrace.fileReadBegin(path);
int bytesRead = 0;
try {
bytesRead = readBytes(b, 0, b.length);
} finally {
IoTrace.fileReadEnd(traceContext, bytesRead == -1 ? 0 : bytesRead);
}
return bytesRead;
}

public int read(byte b[], int off, int len) throws IOException {
Object traceContext = IoTrace.fileReadBegin(path);
int bytesRead = 0;
try {
bytesRead = readBytes(b, off, len);
} finally {
IoTrace.fileReadEnd(traceContext, bytesRead == -1 ? 0 : bytesRead);
}
return bytesRead;
}

private native int readBytes(byte b[], int off, int len) throws IOException;

实际只是调用了native readBytes(byte b[], int off, int len)方法

其他好几个也都是native 方法，像skip()， available()，open(String name) 等等

值得一提的就是，增加了一个获取NIO对象FileChannel的方法：

public FileChannel getChannel() {
synchronized (this) {
if(channel == null) {
channel = FileChannelImpl.open(fd, path, true, false, this);
fd.incrementAndGetUseCount();
}
return channel;
}
}

具体等后面看了NIO相关内容再补充吧！这个方法和单例模式还是非常相像的。

对应的FileOutputStream也是类似的结构：

public FileOutputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null, false);
}

public FileOutputStream(String name, boolean append) throws FileNotFoundException {
this(name != null ? new File(name) : null, append);
}

public FileOutputStream(File file) throws FileNotFoundException {
this(file, false);
}

publid FileOutputStream(File file, boolean append) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if(security != null) {
security.checkWrite(name);
}
if(name == null) {
throw new NullPointerException();
}
if(file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
this.fd = new FileDescriptor();
this.append = append;
this.path = name;
fd.incrementAndGetUseCount();
open(name, append);
}

public FileOutputStream(FileDescriptor fdObj) {
SecurityManager security = System.getSecurityManager();
if (fdObj == null) {
throw new NullPointerException();
}
if (security != null) {
security.checkWrite(fdObj);
}
this.fd = fdObj;
this.path = null;
this.append = false;

fd.incrementAndGetUseCount();
}

FileOutputStream的构造函数相比FileInputStream的多了一个boolean append的参数，所以构造函数多了一个重载的构造函数。

boolean append 参数表示是否从文件内容末尾进行追加，默认是不追加的，采用覆盖模式，即如果文件原本是有内容的，一旦创建了针对这个文件的FileOutputStream，该文件的内容就被覆盖了，因为一旦通过构造函数实例化了FileOutputStream对象，其已经调用了open方法：

private native void open(String name, boolean append) throws FileNotFoundException;

较重要的三个方法也是对OutputStream重写的三个write方法：

public void write(int b) throws IOException {
Object traceContext = IoTrace.fileWriteBegin(path);
int bytesWritten = 0;
try {
write(b, append);
bytesWritten = 1;
} finally {
IoTrace.fileWriteEnd(traceContext, bytesWritten);
}
}

private native void write(int b, boolean append) throws IOException;

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

public void write(byte b[]) throws IOException {
Object traceContext = IoTrace.fileWriteBegin(path);
int bytesWritten = 0;
try {
writeBytes(b, 0, b.length, append);
bytesWritten = b.length;
} finally {
IoTrace.fileWriteEnd(traceContext, bytesWritten);
}
}

public void write(byte b[], int off, int len) throws IOException {
Object traceContext = IoTrace.fileWriteBegin(path);
int bytesWritten = 0;
try {
writeBytes(b, off, len, append);
bytesWritten = len;
} finally {
IoTrace.fileWriteEnd(traceContext, bytesWritten);
}
}

相应的都是调用相关的native方法

也增加了一个获取NIO对象FileChannel的方法：

public FileChannel getChannel() {
synchronized (this) {
if (channel == null) {
channel = FileChannelImpl.open(fd, path, false, true, append, this);
fd.incrementAndGetUseCount();
}
return channel;
}
}

其他的像close()方法最终也是调用的natvie close0() 方法

public void close() throws IOException {
synchronized (closeLock) {
if (closed) {
return;
}
closed = true;
}

if (channel != null) {
fd.decrementAndGetUseCount();
channel.close();
}

int useCount = fd.decrementAndGetUseCount();

if ((useCount <= 0) || !isRunningFinalize()) {
close0();
}
}

private native void close0() throws IOException;

这两个类暂时 看到这里了。