分布式计算 lab1 Socket文件传输

题目：

实验一：Socket程序设计试验

【实验目的及要求】
在Uinx/Linux/Windows 环境下通过socket方式实现一个基于Client/Server 或是P2P模式的文件传输程序。
要求：要求独立完成。
【实验原理和步骤】
1. 确定传输模式：通过socket方式实现一个基于Client/Server或P2P模式的文件传输程序。
2. 如果选择的是Client/Server模式的文件传输程序，则需要分别实现客户端和服务器端程序。客户端：用面向连接的方式实现通信。采用Socket 类对象，接收服务器发送的文件并保存在特定的位置。服务器端：监听客户请求，读取磁盘文件并向客户端发送文件。注意：需要实现文件的读写操作。
3. 如果选择的是P2P模式的文件传输程序，则需要实现一个Peer程序，它即是客户端，也是服务器端。Peer程序需要实现文件上传、下载及文件读写等操作。

我选的是Client/Server传输模式，因为简单嘛。以后有空要把P2P也弄一下，稍微改写代码就行了应该。（虽然应该这种东西几乎都是不可靠加坑爹的= =）

拿到题目的时候，我第一个疑问就是：文件传输，是仅限于txt格式的文本呢？还是指的任意文件？

为什么会这样想呢，因为书上给出的流式Socket的例子是发送一个String类型的消息。我就想，如果是txt文本的话，直接用同样的方法发过去，再把缓冲区里的文本写到文件里就行了。事实证明我果然是Too simple, too naive啊。新手嘛，体谅体谅= =所以果断题意是传输任意文件。我当时没考虑直接用书本的BufferedReader和PrintWriter行不行（比如传一个文件流参数进去，以后有空回来要试试，后天还要考人工智能，所以苦逼的我就先把这问题放一放了，直觉上是可以的）。当时觉得一定有个类是可以很好解决这个问题的，于是就去百度了，发现了一篇不错的东西：http://www.blogjava.net/sterning/archive/2007/10/13/152508.html 博主这里是一个传输大文件的demo。我在其中发现了我想要的东西：DataInputStream和DataOutputStream，这两个东东可以实现文件流传输。

因为这两个类差不多，我就在帮助文档查了下前者。解释如下：

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。DataInputStream 对于多线程访问不一定是安全的。 线程安全是可选的，它由此类方法的使用者负责。

继承关系：java.lang.Object->java.io.InputStream->java.io.FilterInputStream（没打错）->java.io.DataInputStream

看来这个具体类（抽象类InputStream的子类）有个牛逼的地方就是允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。（貌似感觉BufferedReader和PrintWriter可以搞起文件了）

不管了，先自己用着。参考样例里用了BufferedInputStream类，我没用，因为感觉不需要。而且帮助文档解释的不是特别清楚（吐槽：还是MSDN给力啊= =）。事实证明我的想法是对的。

为什么要用流式Socket呢？数据报的不行？

因为流式Socket中有一个ServerSocket类，专门用来接收请求并建立连接。很方便。

照着印象打完了，跑起，成功传输，txt，pdf和jpg都无压力。好，至少框架是OK的。剩下来就是把指定原文件改成由用户在控制台输入文件名了。

思路：用String存起来，在通过数据Socket发到服务器，服务器接收，更新路径。

其实很简单，但是也出错了。

一开始用DataInputStream和DataOutputStream传byte数组，再在服务器用toString转换，发现会乱码，导致无法读取。

于是想对策，能不能用被冷落很久了的BufferedReader和PrintWriter？想了一想，好像真行，又百度了一下，网友推荐String类型的网络传输还是用BufferedReader和PrintWriter比较省心。果断敲进去了，再跑，OK。任务完成。

还留了个疑问，getInputStream()的返回值能不能赋给多个对象？close掉其中一个对其他的有没有影响？（以后写demo检查下，今天时间赶呀）

另外今天对用InputStream和OutputStream的了解又深了些。以前老记不住JAVA的输入。不像C有scanf那么方便。现在熟悉了InputStream和BufferedReader之后，发现其实很简单：

BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));

把BufferedReader想象成一个缓冲区，然后传InputStreamReader进来是告诉BufferedReader，你是一个输入的缓冲区，最后再用System.in定向从哪输入。很好理解。

实验代码：

client:

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

import java.util.Scanner;


//Client类
public class client {

    public static void main(String[] args){
        try {
            
            //定义服务器地址
            InetAddress acceptorHost = InetAddress.getByName("localhost");
            
            //定义服务器端口
            int acceptorPort = 10000;
            
            Socket clientSocket = null;
            
            //定义存放所接收文件的路径
            String fileName = "E:\\dstest\\moveto\\";
            
            while(true)
            {    
                
                Scanner cin = new Scanner(System.in);
                
                //输入-1，则关闭客户；输入其余字符继续传送下一个文件
                System.out.println("enter -1 if you want to quit or any other to stay");
                int flag = cin.nextInt();                
                if(flag == -1)
                    break;
                
                //初始化Socket，构造时就会链接，同时具备连接和传输数据的功能
                clientSocket = new Socket(acceptorHost,acceptorPort);   
                
                System.out.println("enter the file name you want to download\n");                
                
                
                BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
                String temp = consoleReader.readLine();
                
                //新建一个保存当前所接收文件的文件路径的String对象，防止固定路径fileName被修改
                String fullfileName = fileName + temp;                             
                
                //发送所需的文件的文件名至服务器
                OutputStream sendFileName = clientSocket.getOutputStream();
                PrintWriter sendFile = new PrintWriter(new OutputStreamWriter(sendFileName));                
                sendFile.println(temp);
                
                //冲刷缓冲区，使数据全部写入缓冲区，以防Socket的意外关闭
                sendFile.flush();
                
                
                DataInputStream clientInput = new DataInputStream(clientSocket.getInputStream());
                DataOutputStream clentOutput = new DataOutputStream(new FileOutputStream(fullfileName));
                
                //定义缓冲区
                int bufferSize = 8192;
                byte[] buff = new byte[bufferSize];
                
                //从文件流读入byte数组，再输出到Data Socket的缓冲流里
                while(true)
                {
                    int read = 0;
                    if(clientInput != null)
                        read = clientInput.read(buff);
                    
                    if(read == -1)
                        break;
                    
                    clentOutput.write(buff,0,read);
                }
                sendFile.close();
                
                //冲刷缓冲区，使数据全部写入缓冲区，以防Socket的意外关闭
                clentOutput.flush();
                
                clientInput.close();
                clentOutput.close();
                
                
                System.out.println("file is received");            
                
            }
            clientSocket.close();
            System.out.println("Client closed");
            
            
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

server:

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;



//Server类
public class test1 {

    public static void main(String arg[]) {
        
        //定义接收连接Socket端口号
        final int port = 10000;
            
        ServerSocket myServerSocket;
        
        try {
            
            //初始化接收连接Socket
            myServerSocket = new ServerSocket(port);
            
            Socket dataSocket = null;
            
            //定义存放待传送文件的服务器路径
            String fileName = "E:\\dstest\\distributedSystem\\";
            
            
            while(true)
            {
                                   
                Scanner cin = new Scanner(System.in);                
                
                //输入-1，则关闭接收连接Socket与服务器；输入其余字符继续传送下一个文件
                System.out.println("-1 to shut the Server or any other to stay\n");                                
                int flag = cin.nextInt();                
                if(flag == -1)
                    break;            
                
                //等待客户端发起连接请求
                System.out.println("Receiving and Waiting...");
                
                //接收连接
                dataSocket = myServerSocket.accept();                
                System.out.println("Connected!");
                
                //获取输入流，通过输入流获取文件名            
                BufferedReader readName = new BufferedReader(new InputStreamReader(dataSocket.getInputStream()));
                String temp = readName.readLine();
                System.out.println("file name is: " + temp);
                                
                //新建一个保存当前所需文件的文件路径的String对象，防止固定路径fileName被修改
                String fullfileName = fileName + temp;
                
                //创建File变量，获取文件长度
                File fi = new File(fullfileName);
                System.out.println("文件长度: " + (int)fi.length());                
                
                //DataInputStream和DataOutputStream都可以选java.io或是org.omg.CORBA。 本次实验基于本机，所以不存在不同环境下的通讯，所以用java.io里的即可。
                //InputStream 是抽象的超类，不能new，所以用具体的DataInputStream类。书上的OutputStream全部是直接被赋值的，不是new.
                
                DataInputStream fileIn = new DataInputStream(new FileInputStream(fullfileName));
                DataOutputStream fileOut = new DataOutputStream(dataSocket.getOutputStream());
                
                //定义缓冲区
                int bufferSize = 8192;
                byte[] buff = new byte[bufferSize];
                
                //从文件流读入byte数组，再输出到Data Socket的缓冲流里
                while(true)
                {
                    int read = 0;
                    if(fileIn != null)
                        read = fileIn.read(buff);
                    
                    if(read == -1)
                        break;
                    
                    fileOut.write(buff,0,read);
                }
                
                //冲刷缓冲区，使数据全部写入缓冲区，以防Socket的意外关闭
                fileOut.flush();
                
                fileIn.close();
                fileOut.close();
                
                System.out.println("file has been sent");
                
                //关闭数据Socket
                dataSocket.close();
                System.out.println("data socket is closed");
            }
            
            //关闭接收连接Socket与服务器
            myServerSocket.close();
            System.out.println("Sever is closed");
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        
    }
}