手敲简易版 - 文件传输服务器

该文件传输服务器使用到了线程池（抵御高并发），IO（文件传输），网编（网络通信），项目已在Gitee发布，请查看下方连接

谢柯-文件传输服务器

---

这个文件服务器只能传输图片，如果需要改进，则需要动态获取文件后缀，就是一个真正意义上的文件服务器，可以传输任意文件


获取文件后缀可以使用 split() 函数截，也可以使用 commons-io 包下 Filenameutils 工具类的 getExtension（文件名）方法，该方法会直接返回文件后缀名


程序中另外一个非常繁琐的点是，输入输出流之间的交接，使用的是 byte 数组，那么这里也可以优化，文件拷贝工具类 IOUtils 的 copy（输入流，输出流）方法

• socket逻辑线程类

  package com.ldxy;
  
  import java.io.*;
  import java.net.Socket;
  import java.util.UUID;
  
  /**
   * 一些声明信息
   *
   * @author 谢柯
   * @date: 2022/8/20 12:13
   * @description: socket逻辑线程类
   * @since JDK 1.8
   */
  public class UploadRunnable implements Runnable {
  
      private Socket accept;
  
      public UploadRunnable(Socket socket) {
          this.accept = socket;
      }
  
      @Override
      public void run() {
  
          try {
  
  //            生成UUID
              String result = UUID.randomUUID().toString();
  
  //        获取对应客户端的输入流
              BufferedInputStream bufferedInputStream = new BufferedInputStream(accept.getInputStream());
  
  //        本地写入流
              BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("D:\\student\\" + result + ".jpg"));
  
  
  //        读数据
              byte[] bytes = new byte[1024];
              int i = 0;
              String s = null;
  
  //        将文件写入到对应位置
              while ((i = bufferedInputStream.read(bytes)) != -1) {
                  bufferedOutputStream.write(bytes, 0, i);
              }
  
  
  //        控制台输出
              System.out.println(s);
  
  //        输出流，向客户端发送反馈数据
              BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
  
  //        向客户端输出数据
              //   bufferedWriter.write("你发送的数据是：" + s + "\n已收到");
              bufferedWriter.write("收到！！");
  //        换行
              bufferedWriter.newLine();
  //        刷出
              bufferedWriter.flush();
  //        输出结束符
              accept.shutdownOutput();
  
  
  //            释放反馈流
              bufferedWriter.close();
  
  //            释放本地流
              bufferedOutputStream.close();
  
  //            释放客户端
              accept.close();
          } catch (Exception e) {
              System.out.println("出错了！");
          }
      }
  }
  

`

• 客户端

    package com.ldxy;
    
    import java.io.*;
    import java.net.Socket;
    
    /**
     * 一些声明信息
     *
     * @author 谢柯
     * @date: 2022/8/20 11:21
     * @description: 文件传输，客户端
     * @since JDK 1.8
     */
    public class FileSocket {
        public static void main(String[] args) throws IOException {
    
            //        创建客户端对象
            Socket socket = new Socket("127.0.0.1", 6666);
    
    //        创建读对象，将图片从本地读入
            BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("D:\\电脑壁纸\\6fc83c9ef221c76b758a8cbcbbb51e9d.jpg"));
    
    //        获取输出流对象，该对象负责将，读入的图片，传到服务端
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream((socket.getOutputStream()));
    
    //        将发送数据写到输出流
            byte[] bytes = new byte[1024];
            int i = 0;
    
    //        写图片
            while ((i = bufferedInputStream.read(bytes)) != -1) {
                bufferedOutputStream.write(bytes, 0, i);
            }
    
    //        写入结束标记
            socket.shutdownOutput();
    
    //        创建输入，读数据（带缓存的字符输入流）
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    
            char[] chars = new char[1024];
            int i1 = 0;
    
    //        输出数据，该内容由服务器端发送
            while ((i1 = bufferedReader.read(chars)) != -1) {
                System.out.println(new String(chars, 0, i1));
            }
    
    //       释放，文件读入流
            bufferedInputStream.close();
    
    //        将socket释放，会同时释放在该对象上，建立的输出流对象，socket上有输入（接收反馈）和输出（发送数据）两个流
            socket.close();
    
        }
    }

• 服务器

    package com.ldxy;
    
    
    import org.slf4j.LoggerFactory;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    import org.slf4j.Logger;
    
    /**
     * 一些声明信息
     *
     * @author 谢柯
     * @date: 2022/8/20 11:21
     * @description: 文件服务器端
     * @since JDK 1.8
     */
    public class FileServerSocket {
    
        private final static Logger Logger = LoggerFactory.getLogger(FileServerSocket.class);
    
        public static void main(String[] args) throws IOException {
    
            Logger.info("创建ServerSocket对象");
    
    //        创建服务端对象
            ServerSocket serverSocket = new ServerSocket(6666);
    
    //        日志写入
            Logger.info("创建线程池");
    
    //            创建线程池，来抵御高并发
            ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
    //        corePoolSize——核心线程最大值，不能小于0
                    0,
    
    //        maximumPoolSize——最大线程数，不能小于等于0 maximumPoolSize>=corePoolSize
                    10,
    
    //        keepAliveTime——空闲线程最大存活时间，不能小于0
                    2,
    
    //        unit——时间单位
                    TimeUnit.MINUTES,
    
    //        workQueue——任务队列，不能为null
                    new ArrayBlockingQueue<Runnable>(5),
    
    //        threadFactory——创建线程工厂，不能为null
                    Executors.defaultThreadFactory(),
    
    //        handler——任务拒绝策略，不能为null
                    new ThreadPoolExecutor.AbortPolicy()
            );
    
    
    //        多客户端监听
            while (true) {
    
    //        监听,获取对象
                Socket accept = serverSocket.accept();
    
    //            创建对应的线程，将每个Socket对象的执行逻辑封装为一个线程
                UploadRunnable run = new UploadRunnable(accept);
    
    //            提交线程任务
                threadPoolExecutor.submit(run);
    
            }
    
            //serverSocket.close();
        }
    }