<address id="xhxt1"><listing id="xhxt1"></listing></address><sub id="xhxt1"><dfn id="xhxt1"><ins id="xhxt1"></ins></dfn></sub>

    <thead id="xhxt1"><dfn id="xhxt1"><ins id="xhxt1"></ins></dfn></thead>

    Java IO 之 FileInputStream & FileOutputStream源码分析

    Writer????? :李强强

    一、引子

    文件,作为常见的数据源。关于操作文件的字节流就是 — FileInputStream & FileOutputStream。它们是Basic IO字节流中重要的实现类。

    二、FileInputStream源码分析

    FileInputStream源码如下:

    /**
     * FileInputStream 从文件系统的文件中获取输入字节流。文件取决于主机系统。
     * 	比如读取图片等的原始字节流。如果读取字符流,考虑使用 FiLeReader。
     */
    public class SFileInputStream extends InputStream
    {
        /* 文件描述符类---此处用于打开文件的句柄 */
        private final FileDescriptor fd;
    
        /* 引用文件的路径 */
        private final String path;
    
        /* 文件通道,NIO部分 */
        private FileChannel channel = null;
    
        private final Object closeLock = new Object();
        private volatile boolean closed = false;
    
        private static final ThreadLocal<Boolean> runningFinalize =
            new ThreadLocal<>();
    
        private static boolean isRunningFinalize() {
            Boolean val;
            if ((val = runningFinalize.get()) != null)
                return val.booleanValue();
            return false;
        }
    
        /* 通过文件路径名来创建FileInputStream */
        public FileInputStream(String name) throws FileNotFoundException {
            this(name != null ? new File(name) : null);
        }
    
        /* 通过文件来创建FileInputStream */
        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);
        }
    
        /* 通过文件描述符类来创建FileInputStream */
        public FileInputStream(FileDescriptor fdObj) {
            SecurityManager security = System.getSecurityManager();
            if (fdObj == null) {
                throw new NullPointerException();
            }
            if (security != null) {
                security.checkRead(fdObj);
            }
            fd = fdObj;
            path = null;
            fd.incrementAndGetUseCount();
        }
    
        /* 打开文件,为了下一步读取文件内容。native方法 */
        private native void open(String name) throws FileNotFoundException;
    
        /* 从此输入流中读取一个数据字节 */
        public int read() throws IOException {
            Object traceContext = IoTrace.fileReadBegin(path);
            int b = 0;
            try {
                b = read0();
            } finally {
                IoTrace.fileReadEnd(traceContext, b == -1 ? 0 : 1);
            }
            return b;
        }
    
        /* 从此输入流中读取一个数据字节。native方法 */
        private native int read0() throws IOException;
    
        /* 从此输入流中读取多个字节到byte数组中。native方法 */
        private native int readBytes(byte b[], int off, int len) throws IOException;
    
        /* 从此输入流中读取多个字节到byte数组中。 */
        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;
        }
    
        /* 从此输入流中读取最多len个字节到byte数组中。 */
        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;
        }
    
        
        public native long skip(long n) throws IOException;
    
        /* 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读?。ɑ蛱┑墓兰剖S嘧纸谑?。 */
        public native int available() throws IOException;
    
        /* 关闭此文件输入流并释放与此流有关的所有系统资源。 */
        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();
            }
        }
    
        public final FileDescriptor getFD() throws IOException {
            if (fd != null) return fd;
            throw new IOException();
        }
    
        /* 获取此文件输入流的唯一FileChannel对象 */
        public FileChannel getChannel() {
            synchronized (this) {
                if (channel == null) {
                    channel = FileChannelImpl.open(fd, path, true, false, this);
                    fd.incrementAndGetUseCount();
                }
                return channel;
            }
        }
    
        private static native void initIDs();
    
        private native void close0() throws IOException;
    
        static {
            initIDs();
        }
    
        protected void finalize() throws IOException {
            if ((fd != null) &&  (fd != FileDescriptor.in)) {
                runningFinalize.set(Boolean.TRUE);
                try {
                    close();
                } finally {
                    runningFinalize.set(Boolean.FALSE);
                }
            }
        }
    }

    1. 三个核心方法

    三个核心方法,也就是Override(重写)了抽象类InputStreamread方法。

    int read() 方法,即

    public int read() throws IOException

    代码实现中很简单,一个try中调用本地nativeread0()方法,直接从文件输入流中读取一个字节。IoTrace.fileReadEnd(),字面意思是防止文件没有关闭读的通道,导致读文件失败,一直开着读的通道,会造成内存泄露。

    ?

    int read(byte b[]) 方法,即

    public int read(byte b[]) throws IOException

    代码实现也是比较简单的,也是一个try中调用本地nativereadBytes()方法,直接从文件输入流中读取最多b.length个字节到byte数组b中。

     

    int read(byte b[], int off, int len) 方法,即

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

    代码实现和 int read(byte b[])方法 一样,直接从文件输入流中读取最多len个字节到byte数组b中。

    可是这里有个问答:

    Q: 为什么 int read(byte b[]) 方法需要自己独立实现呢? 直接调用 int read(byte b[], int off, int len) 方法,即read(b , 0 , b.length),等价于read(b)?

    A:待完善,希望路过大神回答。。。。向下兼容?? Finally??

     

    2. 值得一提的native方法

    上面核心方法中为什么实现简单,因为工作量都在native方法里面,即JVM里面实现了。native倒是不少一一列举吧:

    native void open(String name) // 打开文件,为了下一步读取文件内容

    native int read0() // 从文件输入流中读取一个字节

    native int readBytes(byte b[], int off, int len) // 从文件输入流中读取,从off句柄开始的len个字节,并存储至b字节数组内。

    native void close0() // 关闭该文件输入流及涉及的资源,比如说如果该文件输入流的FileChannel对被获取后,需要对FileChannel进行close。

     

    其他还有值得一提的就是,在jdk1.4中,新增了NIO包,优化了一些IO处理的速度,所以在FileInputStream和FileOutputStream中新增了FileChannel getChannel()的方法。即获取与该文件输入流相关的 java.nio.channels.FileChannel对象。

    ?

    三、FileOutputStream 源码分析

    FileOutputStream 源码如下:

    /**
     * 文件输入流是用于将数据写入文件或者文件描述符类
     * 	比如写入图片等的原始字节流。如果写入字符流,考虑使用 FiLeWriter。
     */
    public class SFileOutputStream extends OutputStream
    {
        /* 文件描述符类---此处用于打开文件的句柄 */
        private final FileDescriptor fd;
    
        /* 引用文件的路径 */
        private final String path;
    
        /* 如果为 true,则将字节写入文件末尾处,而不是写入文件开始处 */
        private final boolean append;
    
        /* 关联的FileChannel类,懒加载 */
        private FileChannel channel;
    
        private final Object closeLock = new Object();
        private volatile boolean closed = false;
        private static final ThreadLocal<Boolean> runningFinalize =
            new ThreadLocal<>();
    
        private static boolean isRunningFinalize() {
            Boolean val;
            if ((val = runningFinalize.get()) != null)
                return val.booleanValue();
            return false;
        }
    
        /* 通过文件名创建文件输入流 */
        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);
        }
    
        /* 通过文件创建文件输入流,并确定文件写入起始处  */
        public 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();
        }
    
        /* 打开文件,并确定文件写入起始处模式 */
        private native void open(String name, boolean append)
            throws FileNotFoundException;
    
        /* 将指定的字节b写入到该文件输入流,并指定文件写入起始处模式 */
        private native void write(int b, boolean append) throws IOException;
    
        /* 将指定的字节b写入到该文件输入流 */
        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 writeBytes(byte b[], int off, int len, boolean append)
            throws IOException;
    
        /* 将指定的字节数组b写入该文件输入流 */
        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);
            }
        }
    
        /* 将指定len长度的字节数组b写入该文件输入流 */
        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);
            }
        }
    
        /* 关闭此文件输出流并释放与此流有关的所有系统资源 */
        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();
            }
        }
    
         public final FileDescriptor getFD()  throws IOException {
            if (fd != null) return fd;
            throw new IOException();
         }
    
        public FileChannel getChannel() {
            synchronized (this) {
                if (channel == null) {
                    channel = FileChannelImpl.open(fd, path, false, true, append, this);
    
                    fd.incrementAndGetUseCount();
                }
                return channel;
            }
        }
    
        protected void finalize() throws IOException {
            if (fd != null) {
                if (fd == FileDescriptor.out || fd == FileDescriptor.err) {
                    flush();
                } else {
    
                    runningFinalize.set(Boolean.TRUE);
                    try {
                        close();
                    } finally {
                        runningFinalize.set(Boolean.FALSE);
                    }
                }
            }
        }
    
        private native void close0() throws IOException;
    
        private static native void initIDs();
    
        static {
            initIDs();
        }
    
    }

    1. 三个核心方法

    三个核心方法,也就是Override(重写)了抽象类OutputStreamwrite方法。

    void write(int b) 方法,即

    public void write(int b) throws IOException

    代码实现中很简单,一个try中调用本地nativewrite()方法,直接将指定的字节b写入文件输出流。IoTrace.fileReadEnd()的意思和上面FileInputStream意思一致。

    ?

    void write(byte b[]) 方法,即

    public void write(byte b[]) throws IOException

    代码实现也是比较简单的,也是一个try中调用本地nativewriteBytes()方法,直接将指定的字节数组写入该文件输入流。

     

    void write(byte b[], int off, int len) 方法,即

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

    代码实现和 void write(byte b[]) 方法 一样,直接将指定的字节数组写入该文件输入流。

    ?

    2. 值得一提的native方法

    上面核心方法中为什么实现简单,因为工作量都在native方法里面,即JVM里面实现了。native倒是不少一一列举吧:

    native void open(String name) // 打开文件,为了下一步读取文件内容

    native void write(int b, boolean append) // 直接将指定的字节b写入文件输出流

    native native void writeBytes(byte b[], int off, int len, boolean append) // 直接将指定的字节数组写入该文件输入流。

    native void close0() // 关闭该文件输入流及涉及的资源,比如说如果该文件输入流的FileChannel对被获取后,需要对FileChannel进行close。

    ?

    相似之处

    其实到这里,该想一想。两个源码实现很相似,而且native方法也很相似。其实不能说“相似”,应该以“对应”来概括它们。

    它们是一组,是一根吸管的两个孔的关系:“一个Input一个Output”。

     

    休息一下吧~ 看看小广告:

    开源代码都在我的gitHub上哦 — https://github.com/JeffLi1993 作者留言“请手贱,点项目star,支持支持拜托拜托”

     

    四、使用案例

    下面先看代码:

    package org.javacore.io;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /*
     * Copyright [2015] [Jeff Lee]
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     * 
     *   http://www.apache.org/licenses/LICENSE-2.0
     * 
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    
    /**
     * @author Jeff Lee
     * @since 2015-10-8 20:06:03
     * FileInputStream&FileOutputStream使用案例
     */
    public class FileIOStreamT {
    	private static final String thisFilePath = 
    			"src" + File.separator +
    			"org" + File.separator +
    			"javacore" + File.separator +
    			"io" + File.separator +
    			"FileIOStreamT.java";
    	public static void main(String[] args) throws IOException {
    		// 创建文件输入流
    		FileInputStream fileInputStream = new FileInputStream(thisFilePath);
    		// 创建文件输出流
    		FileOutputStream fileOutputStream =  new FileOutputStream("data.txt");
    		
    		// 创建流的最大字节数组
    		byte[] inOutBytes = new byte[fileInputStream.available()];
    		// 将文件输入流读取,保存至inOutBytes数组
    		fileInputStream.read(inOutBytes);
    		// 将inOutBytes数组,写出到data.txt文件中
    		fileOutputStream.write(inOutBytes);
    		
    		fileOutputStream.close();
    		fileInputStream.close();
    	}
    }
    

    运行后,会发现根目录中出现了一个“data.txt”文件,内容为上面的代码。

    1. 简单地分析下源码:

    1、创建了FileInputStream,读取该代码文件为文件输入流。

    2、创建了FileOutputStream,作为文件输出流,输出至data.txt文件。

    3、针对流的字节数组,一个 read ,一个write,完成读取和写入。

    4、关闭流

    2. 代码调用的流程如图所示:

    iostream

    3. 代码虽简单,但是有点小问题

    FileInputStream.available() 是返回流中的估计剩余字节数。所以一般不会用此方法。

    一般做法,比如创建一个 byte数组,大小1K。然后read至其返回值不为-1,一直读取即可。边读边写。

     

    五、思考与小结

    FileInputStream & FileOutputStream 是一对来自 InputStream和OutputStream的实现类。用于本地文件读写(二进制格式按顺序读写)。

    本文小结:

    1、FileInputStream 源码分析

    2、FileOutputStream 资源分析

    3、FileInputStream & FileOutputStream 使用案例

    4、其源码调用过程

     

    欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

    ———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

    原创文章,转载请注明: 转载自并发编程网 – www.gofansmi6.com本文链接地址: Java IO 之 FileInputStream & FileOutputStream源码分析


    FavoriteLoading添加本文到我的收藏
    • Trackback 关闭
    • 评论 (0)
    1. 暂无评论

    您必须 登陆 后才能发表评论

    return top

    爱投彩票 q2q| sic| 0au| gk0| yoq| s0i| iwy| y1e| wam| 1gu| ma1| wm1| yuo| i9y| cyy| 0ic| cs0| oss| q0u| omo| 0cm| ws0| oks| o0k| u8e| cqi| 9qk| mi9| scc| y9i| mia| 9qs| ig9| wsg| y0m| oeq| c8o| y8a| sum| 8iq| co8| gmq| e8e| qeg| 9ug| yc9| eao| c9c| guo| 7qs| eae| wk7| qau| y8y| gkw| 8ai| ym8| ycc| q8c| kyc|