关于关闭BufferedOutputStream

Question

我正在尝试使用TCP开发一个简单的Java文件传输应用程序。我的当前服务器代码如下：

package tcp.ftp;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class FTPServer {

    public static void main(String[] args) {
        new FTPServer().go();
    }

    void go() {
        try {
            ServerSocket server = new ServerSocket(2015);
            System.out.println("server is running ....!");
            while (true) {
                Socket socket = server.accept();
                BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String file = reader.readLine();
                System.out.println("file to be downloaded is : " + file);
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
                BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
                while (true) {
                    int octet = bis.read();
                    if (octet == -1) {
                        break;
                    }
                    bos.write(octet);
                }
                 bos.flush();
                //bos.close();

            }
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
    }

}

使用我上面的当前服务器代码，下线操作不像预期的那样工作。上面的代码将部分文件发送给客户端，而不是整个文件。请注意，我使用了刷新方法来刷新缓冲区。但是，当我用close ()方法替换flush ()方法时，文件会在没有任何损失的情况下完全发送到客户端。有人能解释一下这种行为吗？

更新：这里是我客户端的代码：

package tcp.ftp;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 *
 * @author aaa
 */
public class FTPClient {

    public static void main(String[] args) {
        String file = "JasperReports-Ultimate-Guide-3.pdf";
        try {
            InetAddress address = InetAddress.getLocalHost();
            Socket socket = new Socket(address, 2015);
            System.out.println("connection successfully established ....!");
            PrintWriter pw = new PrintWriter(socket.getOutputStream());
            pw.println(file);
            pw.flush();
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy" + file));
            while (true) {
                int octet = bis.read();
                if (octet == -1) {
                    break;
                }
                bos.write(octet);
            }
            bos.flush();
            System.out.println("file download is complete ...!");

        } catch (UnknownHostException ex) {
            System.out.println(ex.getMessage());
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
    }
}

另一种不使用套接字的行为。将文件从源复制到目标的代码如下：

    public class CopieFile {
     static void fastCopy(String source, String destination) {

    try {
        FileInputStream fis = new FileInputStream(source);
        BufferedInputStream bis = new BufferedInputStream(fis);
        FileOutputStream fos = new FileOutputStream(destination);
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        while (true) {
            int octet = bis.read();
            if (octet == -1) {
                break;
            }
            bos.write(octet);
        }
        bos.flush();
    } catch (FileNotFoundException ex) {
        System.out.println(ex.getMessage());
    } catch (IOException ex) {
        System.out.println(ex.getMessage());
    }
}
public static void main(String[] args) throws IOException {
        String source = "...";
        String destination = "...";
        fastCopy(source, destination);
}// end main
}// end class

上述代码可将文件从一个位置复制到另一个位置，而不会丢失。注意，我没有关闭溪流。

Answer 1

如果您从未关闭该流，则客户端将永远得不到流的结束，因此它将永远不会退出read循环。

无论如何，流和套接字即将超出作用域，所以如果不关闭它们，就会出现资源泄漏。