Java网络编程详解（四）TCP通信实现文件上传(多文件上传、多线程、服务端常启)

一、文件上传图解

1. 【客户端】输入流，从硬盘读取文件数据到程序中。
2. 【客户端】输出路，写出文件数据到服务端
3. 【服务端】输入路，读取文件数据到服务端程序
4. 【服务端】输出流，写出文件数据到服务器硬盘中

二、文件上传步骤

1. 客户端使用本地字节输入流，读取要上传的文件
2. 客户端使用网络字节输出流，把读到文件上传到服务器
3. 服务器使用网络字节输入流，读取客户端上传的文件
4. 服务器使用本地字节输出流，把读取到的文件，保存到服务器的硬盘上
5. 服务器使用网络字节输出流，给客户端回写一个“上传成功”
6. 客户端使用网络字节输入流，读取服务器回写的数据
7. 释放资源

注意：

• 客户端与服务器和本地硬盘进行读写，需要使用自己创建的字节流对象（本地流）
• 客户端和服务器之间进行读写，必须使用Socket中提供的字节流对象（网络流）

明确：

• 数据源
• 数据目的地

三、 代码详解：

服务器端：

package Internet.FileUpload;

/*
    文件上传案例服务器端：读取客户端上传的文件，保存到服务器的硬盘，给客户端回写"上传成功"

    明确：
        数据源：客户端上传的文件
        目的地：Texts/Text.txt

    实现步骤：
        1. 创建一个服务器ServerSocket对象，和系统要指定的端口号
        2. 使用ServerSocket对象中的方法accept，获取请求的客户端Socket对象
        3. 使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
        4. 判断 Texts 文件夹是否存在，不存在则创建
        5. 创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
        6. 使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
        7. 使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
        8. 使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
        9. 使用网络字节输出流OutputStream对象中的方法write，给客户端回写"上传成功"
        10. 释放资源（FileOutputStream、Socket、ServerSocket）
 */

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

public class TCPServer {
    public static void main(String[] args) throws IOException {
        //1. 创建一个服务器ServerSocket对象，和系统要指定的端口号
        ServerSocket server = new ServerSocket(9999);

        /*
        让服务器一直处于监听状态（死循环accept方法）
        有一个客户端上传文件，就保存一个文件
         */
        while(true)
        {
            //2. 使用ServerSocket对象中的方法accept，获取请求的客户端Socket对象
            Socket socket = server.accept();

            /*
            使用多线程技术，提高程序的效率
            有一个客户端上传文件，就开启一个线程，完成文件的上传
             */

            new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        //3. 使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
                        InputStream is = socket.getInputStream();

                        //4. 判断 Texts 文件夹是否存在，不存在则创建
                        File file = new File("Texts/");
                        if (!file.exists()){
                            file.mkdirs();
                        }

                        /*
                        自定义一个文件的命名规则：防止同名文件被覆盖
                        规则：域名+毫秒值+随机数
                         */
                        String fileName = "itcast"+System.currentTimeMillis()+new Random().nextInt(999999)+".txt";

                        //5. 创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
                        FileOutputStream fos = new FileOutputStream(file+"/"+fileName);

                        //6. 使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while ((len = is.read(bytes)) != -1)
                        {
                            //7. 使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
                            fos.write(bytes,0,len);
                        }

                        //8. 使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
                        //9. 使用网络字节输出流OutputStream对象中的方法write，给客户端回写"上传成功"
                        socket.getOutputStream().write("上传成功".getBytes());
                        //10. 释放资源（FileOutputStream、Socket、ServerSocket）
                        fos.close();
                        socket.close();
                    }catch (IOException e)
                    {
                        System.out.println(e);
                    }
                }
            }).start();
        }
    }
}

客户端：

package Internet.FileUpload;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/*
    文件上传案例的客户端：读取本地文件，上传到服务器，读取服务器回写的数据

    明确：
        数据源：Text.txt
        目的地：服务器

    实现步骤：
        1. 创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
        2. 创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
        3. 使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
        4. 使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
        5. 使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
        6. 使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
        7. 使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
        8. 释放资源（FileInputStream、Socket）
 */
public class TCPClient {
    public static void main(String[] args) throws IOException {
        //1. 创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("Text.txt");

        //2. 创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1",9999);

        //3. 使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
        OutputStream os = socket.getOutputStream();

        //4. 使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = fis.read(bytes)) != -1)
        {
            //5. 使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
            os.write(bytes,0,len);
        }
        socket.shutdownOutput();

        //6. 使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();

        //7. 使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
        while ((len = is.read(bytes)) != -1)
        {
            System.out.println(new String(bytes,0,len));
        }

        //8. 释放资源（FileInputStream、Socket）
        fis.close();
        socket.close();
    }
}

运行结果：

先启动服务器端、再启动客户端，启动客户端后文件成功上传。