JAVA利用socket实现简单的文件上传（多线程）

---

简单的文件上传（socket学习）

客户端代码

package com.guet.socketStudy;

import java.io.*;

import java.net.Socket;
import java.nio.charset.StandardCharsets;

/**
 * @Author: HML
 * @Date: 2021/3/8  9:22
 * @Version 1.0
 */
public class ClientThreadDemo {

    private static String filepath = "E:\\1.jpg";
    private static String IP = "127.0.0.1";
    private static int PORT = 123;
    public static void main(String[] args) throws IOException {

        //1.创建一个本地的文件输入流，绑定要读取的本地数据流
        FileInputStream fi = new FileInputStream(filepath);
        //2.创建socket对象
        Socket socket = new Socket(IP,PORT);
        //3.使用网络字节输出流outputStream对象中的方法write，给服务器发送数据
        OutputStream outputStream = socket.getOutputStream();
        //4.使用本地字节输入流FileInputStream对象中的read方法。读取本地文件
        //这里使用DataOutputStream，这是个与平台无关的数据流
        /**
         * 两个与平台无关的数据操作流，分别为数据输出流dataoutputstream，和数据输入流 datainputstream 通常数据
         * 输出流会按照一定的格式将数据输出，在通过数据输入流按照一定的格式将数据读入，这样就可以方便的对数据进行处理
         */
        /**
         * 构造方法：
         *   DataOutputStream(OutputStream out)
         *           创建一个新的数据输出流，将数据写入指定基础输出流。
         */
        DataOutputStream ds = new DataOutputStream(outputStream);
        ds.writeUTF(filepath);
        ds.flush();
        int len = 0;
        byte[] bytes = new byte[1024*1024];
        while ((len = fi.read(bytes)) != -1){
            outputStream.write(bytes,0,len);
        }
        socket.shutdownOutput();
        //5.使用网络字节输入流InputStream对象中的方法read,读取服务器回写的数据
        InputStream inputStream = socket.getInputStream();
        while ((len = inputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len, StandardCharsets.UTF_8));
            System.out.println("结束");
        }
        fi.close();
        ds.close();
        socket.close();
    }
}

服务器端代码

package com.guet.socketStudy;



import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author: HML
 * @Date: 2021/3/8  9:22
 * @Version 1.0
 */
public class ServerThreadDemo {
    private static final int PORT =123;
    public static void main(String[] args) {


        //开启线程用来接收客户端连接
        /**
         * corePoolSize:核心线程池大小
         * maximumPoolSize：最大线程池大小
         * keepAliveTime：线程最大空闲时间，0L:该参数默认对核心线程无效，而FixedThreadPool全部为核心线程；
         * TimeUnit:时间单位
         *
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 200, 0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingDeque<>(1024), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        try {
            //1.开启服务端socket，创建服务器serverSocket对象和系统要指定的端口号
            ServerSocket server = new ServerSocket(PORT);
            while (true) {
                //2.使用ServerSocket对象中的accept()方法，获取请求客户端的socket
                Socket socket = server.accept();
                //开启线程，这里实现了每连接一个客户端就开启一个线程
                Runnable runnable = () -> {
                    try {
                        //3.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
                        InputStream inputStream = socket.getInputStream();
                        //使用DataInputStream，输出流会按照一定的格式将数据输出，在通过数据输入流按照一定的格式将数据读入，这样就可以方便的对数据进行处理
                        DataInputStream ds = new DataInputStream(inputStream);
                        //读取传过来的文件名
                        String fileNames = ds.readUTF();
                        System.out.println("传过来的文件名是："+fileNames);
                        //4.判断文件夹是否存在
                        File file = new File("D:\\test");
                        if (file.exists()) {
                            file.mkdirs();
                        }
                        //防止文件重复
                        String fileName = System.currentTimeMillis() + new Random(9999).nextInt() + ".jpg";
                        //5.创建一个本地字节输出流FileOutputStream对象，构造方法要绑定输出的目的地
                        FileOutputStream fo = new FileOutputStream(file + "\\" + fileName);
                        int len = 0;
                        byte[] bytes = new byte[1024 * 1024];
                        //6.使用InputStream汇总的read()，读取客户端上传的文件,这里我们使用数组来做，效率比较快
                        while ((len = inputStream.read(bytes)) != -1) {
                            //7.使用本地输出流对象FileOutputStream对象中的write()，把读取到的文件保存在服务器的硬盘上
                            fo.write(bytes, 0, len);
                        }
                        System.out.println("文件上传到：" + file + "\\" + fileName);
                        //8.使用socket对象中的getOutputStream，获取网络字节输出流OutputStream
                        //9.使用OutputStream对象的write，回响客户端数据“上传成功”
                        socket.getOutputStream().write("上传成功".getBytes());
                        fo.close();
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                        System.out.println("上传错误");
                    }
                };
                threadPoolExecutor.execute(runnable);
            }
            //这里服务器不用关闭了
            } catch(IOException e){
                e.printStackTrace();
            }
        System.out.println("服务器关闭");
        }
}