用java实现的简单Server/Client文件传输

老师留作业了，是一道网络编程题目，socket知识在先，requirement如下：

• 用一种编程语言实现一个简单的Server/Client程序；
• 该程序的主要功能是利用Client从Server端下载一个文件；
• 在下载之前，需要有一定的用户身份验证机制（说白了就是先输入以下用户名和密码）；
• Server应该是多线程机制的，即为每个Client请求Server都要有一个线程去处理，而不是所有的Client都是一个Server线程处理。

ok，这就是需求，单从编程角度来讲，题目不难，单老师说过一句话，我觉得非常有道理，“看一万个程序，不如自己亲自写一个程序，写一万个程序，不如努力写一个好程序”，所以我就利用十一假期的最后两天，完成了这样一个作业，当然大部分时间还是画在了学习不太熟悉的python上。在这里，还要感谢一下CSDN上“wumingabc的专栏”的一篇blog，参考了他的一些代码。

废话少说，上code（这篇是java版，python版）：

处理流程：

1. server启动，监听client请求；
2. client启动；
3. server监听到client，发送“Hi”；
4. client收到“Hi”
5. client要求用户输入用户名；
6. 用户输入用户名（如yangsq），发送到服务器（形式为“username:yangsq”）；
7. 服务器验证是否存在这样一个用户，如果有到step 8，否则转到5；
8. client用求用户输入密码（如123456），发送到服务器（形式为“password:123456”）；
9. 服务器验证密码是否正确，不正确转到step 8，正确开始传输文件（为了简单，文件预先指定好）；
10. client收到文件，结束后发送“bye”；同时server端收到“bye”后结束线程。

服务器端：

java 代码

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

public class SimpleServer extends Thread{
    private static final int DEFAULT_PORT = 4444;
    private static final String DEFAULT_FILE_NAME = "PyNet.pdf";
    private Socket socket;

    public SimpleServer(Socket socket){
        this.socket = socket;
        start();
    }

    @Override
    public void run() {
        System.out.println("Connected from " + socket.getRemoteSocketAddress());
        try {
            BufferedReader in = new BufferedReader(
                    new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(
                    new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
            String inputLine, outputLine;

            HandleInput handleInput = new HandleInput();
            outputLine = handleInput.handle(null);
            out.println(outputLine);

            while((inputLine = in.readLine()) != null){
                outputLine = handleInput.handle(inputLine);
                out.println(outputLine);
                out.flush();
                if(outputLine.equals("bye"))
                    break;
                if(outputLine.equals("password:valid")){
                    //prepare for the transmission of the file
                    Thread.sleep(2000);
                    InputStream fileInput = new FileInputStream(new File(DEFAULT_FILE_NAME));
                    OutputStream fileOutput = new DataOutputStream(
                            new BufferedOutputStream(socket.getOutputStream()));
                    byte[] buf = new byte[2048];

                    //transmit the file
                    int num = fileInput.read(buf);
                    while(num != -1){
                        fileOutput.write(buf, 0, num);
                        fileOutput.flush();
                        num = fileInput.read(buf);
                    }

                    fileInput.close();
                    fileOutput.close();
                }
            }

            in.close();
            out.close();
            System.out.println("Disconnected from " + socket.getRemoteSocketAddress());
            socket.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    private class HandleInput{
        private  Map userInfo = new HashMap();
        private String username = "";
        private String password = "";

        public HandleInput(){
            userInfo.put("yangsq", "yangsq");
            userInfo.put("abc", "abc");
            userInfo.put("123", "123");
        }

        public String handle(String input){
            String output = "";
            if(input == null)
                output = "Hi";
            else if(input.startsWith("username")){
                username = input.split(":")[1];
                if(userInfo.containsKey(username))
                    output = "username:valid";
                else
                    output = "username:invalid";
            }else if(input.startsWith("password")){
                password = input.split(":")[1];
                if(userInfo.get(username).equals(password))
                    output = "password:valid";
                else
                    output = "password:invalid";
            }else if(input.equals("bye")){
                output = "bye";
            }
            return output;
        }
    }

    public static void main(String[] args) {

        int port = DEFAULT_PORT;

        if(args.length > 0){
            port = Integer.parseInt(args[0]);
        }

        try {
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.println("Server Started");
            try {
                while(true){
                    Socket theSocket = serverSocket.accept();
                    try {
                        new SimpleServer(theSocket);
                    } catch (Exception e) {
                        e.printStackTrace();
                        theSocket.close();
                    }
                }
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            } finally {
                if(serverSocket != null)
                    serverSocket.close();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

说明：

• main函数是Server的启动点，在这里我们建立了一个ServerSocket的实例，这个类是java中专门进行Server端编程的，它可以进行很多的复杂配置，这里知识把它建立在了一个端口之上（line-125），然后为请求返回socket（line-131）。
• SimpleServer类继承了Thread，也就是说，我的想法是为每一个Client请求，都有一个SimpleServer去处理。这是怎样实现的呢？看line-128到line-136，这里ServerSocket的实例在端口4444进行监听，只要有一个请求，就new一个SimpleServer去处理（如果没有请求，程序就会阻塞在ServerSocket的accept方法上line-129）
• 既然SimpleServer继承了Thread，那么它的最重要的方法就是run（line-29），可以看到，在new SimpleServer的时候就启动了它的run方法。
• SimpleServer的主要处理流程在line-42到line-67，为了更清晰，把其中的用户身份验证提出来组成一个内部类HandleInput。
• 负责文件传输的是line-48到line-66，也即clien的密码正确后开始。这里需要说明的是流的实现，与用户交互的时候我们用的是New IO，他们是面向字节（1字节=2byte）的，这很合适，因为我们的用户信息都是字节的（简单的说就是面向asc字符的），所以这里我们就用了readline和println方法（这两个都是Reader和Writer的方法）；但是我们要传输的是一个二进制文件（说白了就是面向byte的），所以用New IO就不合适了，所以转向了InputStream（读入文件）和OutputStream（把文件通过socket写出）。

客户端：

java 代码

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.net.Socket;
import java.net.UnknownHostException;

public class SimpleClient {
    private static final int DEFAULT_PORT = 4444;
    private static final String DEFAULT_HOST = "localhost";

    public static void main(String[] args) {
        String host = DEFAULT_HOST;
        int port = DEFAULT_PORT;

        if(args.length > 0){
            host = args[0];
        }

        if(args.length >1 ){
            port = Integer.parseInt(args[1]);
        }

        Socket theSocket = null;
        PrintWriter out = null;
        BufferedReader in = null, userIn = null;

        try {
            theSocket = new Socket(host, port);

            in = new BufferedReader(
                    new InputStreamReader(theSocket.getInputStream()));
            out = new PrintWriter(theSocket.getOutputStream());
            userIn = new BufferedReader(
                    new InputStreamReader(System.in));

            System.out.println("Connected to the simple file server");
            String fromUser, fromServer;

            while((fromServer = in.readLine()) != null){
                if(fromServer.equals("bye"))
                    break;
                else if(fromServer.equals("Hi")){
                    System.out.println("Do you want to get the 'PyNet.pdf' file?(y/n):");
                    fromUser = userIn.readLine();
                    if(fromUser.equals("y")){
                        System.out.println("Please input your username:");
                        fromUser = userIn.readLine();
                        out.println("username:" + fromUser);
                        out.flush();//notice: if this sentence is lost, the info will not arrive at server side
                    }else
                        break;
                }else if(fromServer.startsWith("username")){
                    if(fromServer.split(":")[1].equals("valid")){
                        System.out.println("Please input your password:");
                        fromUser = userIn.readLine();
                        out.println("password:" + fromUser);
                        out.flush();
                    }else{
                        System.out.println("Please input your username:");
                        fromUser = userIn.readLine();
                        out.println("username:" + fromUser);
                        out.flush();
                    }
                }else if(fromServer.startsWith("password")){
                    if(fromServer.split(":")[1].equals("valid")){
                        System.out.println("Downloading...");

                        //prepare for the receiving
                        File newFile = new File("new.pdf");
                        newFile.createNewFile();
                        RandomAccessFile raf = new RandomAccessFile(newFile, "rw");

                        InputStream fileInput = new DataInputStream(
                                new BufferedInputStream(theSocket.getInputStream()));
                        byte[] buf = new byte[2048];

                        //receiving
                        int num = fileInput.read(buf);
                        while(num != -1){
                            raf.write(buf, 0, num);
                            raf.skipBytes(num);
                            num = fileInput.read(buf);
                        }

                        in.close();
                        raf.close();
                        System.out.println("File download is finished");
                        break;
                    }else{
                        System.out.println("Please input your password:");
                        fromUser = userIn.readLine();
                        out.println("password:" + fromUser);
                        out.flush();
                    }
                }
            }

            out.println("bye");
            out.flush();

            out.close();
            in.close();
            userIn.close();
            theSocket.close();
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

这个比较简单，除了用户交互外，最核心的就是line-71到line-94这段处理文件下载的了，当SimpleClient收到服务器的“password:valid"就表示用户身份验证通过，可以执行文件下载了。这部分也是混合使用了New IO和Old IO，原因和上边解释的一样。

这里还要强调一点的是在网络编程的时候，println以后，一定要flush以下。为什么呢？学过网络的人都知道，当一个package太小是，网络并不会把它发出去，而是等到足够大时。我在实际测试时，就忘记了在println后写flush，结果这边明明已经out出了，但Server端就是在那塞着，这个问题困扰了我半天，呵呵。