客户端发送一个本地文件给服务器，服务器接收到这个文件并且存储到指定的文件夹中，并且给客户端回写“上传成功”

客户端

  1. package JDBC_DemoDay07.TCP;/*
  3.     @create 2021--01--05--14:07
  4. */
  6. import java.io.FileInputStream;
  7. import java.io.FileNotFoundException;
  8. import java.io.InputStream;
  9. import java.io.OutputStream;
  10. import java.net.Socket;
  12. /**
  13.  * 文件上传案例的客户端，读取本地文件，上传到服务器，读取服务器回写的数据
  14.  *
  15.  *      实现步骤：
  16.  *              1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定读取的数据源
  17.  *              2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
  18.  *              3.使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
  19.  *              4.使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
  20.  *              5.使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
  21.  *              6.使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
  22.  *              7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
  23.  *              8.释放资源（FileInputStream，Socket）
  24.  */
  25. public class TCPClient {
  26.     public static void main(String[] args) {
  27.         try {
  28.             //1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定读取的数据源
  29.             FileInputStream fis = new FileInputStream("E:\\照骗\\A.JPG");
  31.             // 2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
  32.             Socket socket = new Socket("localhost", 8898);
  34.             // 3.使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
  35.             OutputStream os = socket.getOutputStream();
  37.             // 4.使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
  38.             byte[] bytes = new byte[1024];
  39.             int len = 0;
  40.             while ((len = fis.read(bytes)) != -1) {
  41.                 //5.使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
  42.                 os.write(bytes, 0, len);
  43.             }
  45.             /**
  46.              * 解决：上传完文件，给服务器写一个结束标记
  47.              */
  49.             socket.shutdownOutput();
  51.             //6.使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
  52.             InputStream is = socket.getInputStream();
  54.             //7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
  55.             while ((len = is.read(bytes)) != -1) {
  56.                 System.out.println(new String(bytes, 0, len));
  57.             }
  59.             fis.close();
  60.             socket.close();
  61.         } catch (Exception e) {
  62.             e.printStackTrace();
  63.         }
  64.     }
  65. }

服务器端

利用多线程处理多个客户端上传的文件，提高效率

  1. package JDBC_DemoDay07.TCP;/*
  3.     @create 2021--01--05--14:08
  4. */
  6. import java.io.*;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9. import java.util.Random;
  11. /**
  12.  * 文件上传案例服务器端：读取客户端上传的文件，保存到服务器的硬盘，给客户端回写“上传成功”
  13.  * <p>
  14.  * 明确：
  15.  * 数据源：客户端上传的文件
  16.  * 目的地：服务器的硬盘 D:\\a\\1.jpg
  17.  * <p>
  18.  * 实现步骤：
  19.  * 1.创建一个服务器ServerSocket对象，和系统要指定的端口号
  20.  * 2.使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
  21.  * 3.使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
  22.  * 4.判断D:\\a文件夹是否存在，不存在则创建
  23.  * 5.创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
  24.  * 6.使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
  25.  * 7.使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
  26.  * 8.使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
  27.  * 9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写“上传成功”
  28.  * 10.释放资源（FileOutputStream，Socket，ServerSocket）
  29.  */
  30. public class TCPServer {
  31.     public static void main(String[] args) {
  32.         try {
  33.             //1.创建一个服务器ServerSocket对象，和系统要指定的端口号
  34.             ServerSocket server = new ServerSocket(8898);
  36.             //2.使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
  37.             /**
  38.              * 让服务器一直处于监听状态（死循环accept方法）
  39.              * 有一个客户端上传文件，就保存一个文件
  40.              */
  42.             while (true) {
  43.                 Socket socket = server.accept();
  45.                 /**
  46.                  * 使用多线程技术，提高程序的效率
  47.                  * 有一个客户端上传文件，就开启一个线程，完成文件的上传
  48.                  */
  49.                 new Thread(new Runnable() {
  50.                     //完成文件的上传
  51.                     @Override
  52.                     public void run() {
  53.                         try {
  54.                             //3.使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
  55.                             InputStream is = socket.getInputStream();
  57.                             //4.判断D:\\a文件夹是否存在，不存在则创建
  58.                             File file = new File("d:\\a");
  59.                             if (!file.exists()) {
  60.                                 file.mkdir();
  61.                             }
  63.                             /**
  64.                              * 自定义一个文件的命名规则：防止同名的文件被覆盖
  65.                              * 规则：域名+毫秒值+随机数
  66.                              */
  68.                             String fileName = "itcast" + System.currentTimeMillis() + new Random().nextInt(1010) + ".jpg";
  70.                             //5.创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
  71.                             FileOutputStream fos = new FileOutputStream(file + "\\" + fileName);
  73.                             //6.使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
  74.                             byte[] bytes = new byte[1024];
  75.                             int len = 0;
  76.                             while ((len = is.read(bytes)) != -1) {
  78.                                 //7.使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
  79.                                 fos.write(bytes, 0, len);
  81.                             }
  83.                             //8.使用Socket对象中的方法getOutputStream，获取到网络字节输出流OutputStream对象
  84.                             OutputStream os = socket.getOutputStream();
  86.                             //9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写“上传成功”
  87.                             os.write("收到谢谢".getBytes());
  89.                             //10.释放资源（FileOutputStream，Socket，ServerSocket）
  90.                             fos.close();
  91.                             socket.close();
  92.                         } catch (Exception e) {
  94.                         }
  96.                     }
  97.                 }).start();
  100.             }
  103.             //服务器就不用关闭了
  104.             //server.close();
  106.         } catch (IOException e) {
  107.             e.printStackTrace();
  108.         }
  109.     }
  110. }

服务器端接收到客户端文件中的数据，向服务器端的另一个文件中写出，接收到文件内容，写到某个文件中

客户端

  1. package Test23_Demo.Demo06;/*
  3.     @create 2020--12--16--15:14
  4. */
  6. import java.io.FileInputStream;
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.io.OutputStream;
  10. import java.net.Socket;
  12. /**
  13.  * 上传文件
  14.  * 读取文件的内容，发送给服务器端
  15.  */
  16. public class client {
  17.     public static void main(String[] args) throws IOException {
  18.         //建立客户端
  19.         Socket socket = new Socket("localhost", 8888);
  20.         //建立连接后，获取socket的io流
  21.         OutputStream outputStream = socket.getOutputStream();
  23.         //获取文件的对象
  24.         FileInputStream fis = new FileInputStream("stu.txt");
  26.         //读取文件的内容
  27.         int b = -1;
  28.         while ((b = fis.read()) != -1) {
  29.             outputStream.write(b);
  30.             //输出数据给服务器
  31.         }
  33.         //关闭流
  34.         fis.close();
  36.         //告知服务器，不再发送数据了
  37.         socket.shutdownOutput();
  39.         //获取输入流，接收服务器端的相应
  40.         InputStream in = socket.getInputStream();
  41.         int read = in.read();
  42.         System.out.println((char) read);
  44.         //关闭socket
  45.         socket.close();
  46.     }
  47. }

服务器端

  1. package Test23_Demo.Demo06;/*
  3.     @create 2020--12--16--15:13
  4. */
  6. import HeiMa.Demo.Input;
  8. import java.io.FileOutputStream;
  9. import java.io.IOException;
  10. import java.io.InputStream;
  11. import java.io.OutputStream;
  12. import java.net.ServerSocket;
  13. import java.net.Socket;
  15. public class server {
  16.     public static void main(String[] args) throws IOException {
  17.         //建立服务器
  18.         ServerSocket serverSocket = new ServerSocket(8888);
  20.         //获取流
  21.         Socket accept = serverSocket.accept();
  23.         //建立连接后，获取socket的流
  24.         InputStream in = accept.getInputStream();
  25.         //获取到上传文的内容，要有一个文件
  26.         FileOutputStream fos = new FileOutputStream("ASCII码表完整版.doc");
  27.         //反复使用一个字节读取
  28.         int b = -1;
  29.         while ((b = in.read()) != -1) {
  30.             //一次读取一个字节，最终这个文件接收了所有的上传数据
  31.             fos.write(b);
  32.         }
  34.         //关闭io流
  35.         fos.close();
  38.         //给客户端返回一个相应 - o
  39.         OutputStream out = accept.getOutputStream();
  40.         String content = "o";
  41.         out.write(content.getBytes());
  43.         //关闭socket
  44.         accept.close();
  45.         serverSocket.close();
  46.     }
  47. }