要求

客户端向服务端传输一个文件，服务端接受文件之后将文件保存在本地，并向客户端返回 接收成功 的信息，客户端接收到信息之后将信息打印到控制台上。

分析

客户端向服务器传输文件，实质上就是将本地的文件变成文件流，然后写入到Socket的OutputStream中
然后服务器将OutputStream写入到文件流中，进行保存文件的操作。
服务端向客户端返回信息，只用拿到客户端的Socket 然后把返回的信息写入OutputStream中就可以了。
客户端接收服务端返回的信息，只需要在传输完文件之后去获取客户端Socket的InputStream（会一直等待服务器），然后把流里面的内容转成字符串就可以了。

注意

由于数据是在网络中传输的，服务端读取流的时候是无法while_((_len = inputStream.read_(_buffer_)) _!= -1_)_ 来判断流是否结束的（本地文件可以有EOF），因此，需要我们在客户端传输数据结束之后，给服务端一个结束的信号socket.shutdownOutput_()_

代码

  1. package test21;
  3. import org.junit.Test;
  5. import java.io.*;
  6. import java.net.InetAddress;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  10. /**
  11.  * Created By Intellij IDEA
  12.  *
  13.  * @author Xinrui Yu
  14.  * @date 2021/12/5 21:10 星期日
  15.  */
  16. public class SocketServerTest2 {
  17.     @Test
  18.     public void client(){
  19.         Socket socket = null;
  20.         FileInputStream fileInputStream = null;
  21.         BufferedInputStream bufferedInputStream = null;
  22.         InputStream inputStream = null;
  23.         try{
  24.             fileInputStream = new FileInputStream("img.jpg");
  25.             bufferedInputStream = new BufferedInputStream(fileInputStream);
  26.             InetAddress ip = InetAddress.getByName("127.0.0.1");
  27.             socket = new Socket(ip,8080);
  28.             OutputStream outputStream = socket.getOutputStream();
  29.             byte[] buffer = new byte[1024];
  30.             int len;
  31.             while((len = bufferedInputStream.read(buffer)) != -1){
  32.                 outputStream.write(buffer,0,len);
  33.             }
  34.             socket.shutdownOutput();
  35.             inputStream = socket.getInputStream();
  36.             byte[] buffer2 = new byte[1024];
  37.             int len2;
  38.             while((len2 = inputStream.read(buffer2)) != -1){
  39.                 String str = new String(buffer2,0,len2);
  40.                 System.out.print(str);
  41.             }
  42.         }catch (IOException e){
  43.             e.printStackTrace();
  44.         }finally {
  45.             if(bufferedInputStream != null){
  46.                 try {
  47.                     bufferedInputStream.close();
  48.                 } catch (IOException e) {
  49.                     e.printStackTrace();
  50.                 }
  51.             }
  52.             if(inputStream != null){
  53.                 try {
  54.                     inputStream.close();
  55.                 } catch (IOException e) {
  56.                     e.printStackTrace();
  57.                 }
  58.             }
  59.             if(socket != null){
  60.                 try {
  61.                     socket.close();
  62.                 } catch (IOException e) {
  63.                     e.printStackTrace();
  64.                 }
  65.             }
  66.         }
  67.     }
  69.     @Test
  70.     public void server(){
  71.         ServerSocket serverSocket = null;
  72.         BufferedOutputStream bufferedOutputStream = null;
  73.         InputStream inputStream = null;
  74.         OutputStream outputStream = null;
  75.         try{
  76.             FileOutputStream fileOutputStream = new FileOutputStream("SocketImage.png");
  77.             bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
  78.             serverSocket = new ServerSocket(8080);
  79.             Socket clientSocket = serverSocket.accept();
  80.             inputStream = clientSocket.getInputStream();
  81.             int len;
  82.             byte[] buffer = new byte[1024];
  83.             while((len = inputStream.read(buffer)) != -1){
  84.                 bufferedOutputStream.write(buffer,0,len);
  85.             }
  86.             System.out.println("成功收到来自：" + clientSocket.getInetAddress().getHostAddress() + "的图片");
  87.             outputStream = clientSocket.getOutputStream();
  88.             outputStream.write("照片已收到！谢谢你！".getBytes());
  89.             Thread.sleep(3000);
  90.         }catch (IOException | InterruptedException e){
  91.             e.printStackTrace();
  92.         }finally {
  93.             if(bufferedOutputStream != null){
  94.                 try {
  95.                     bufferedOutputStream.close();
  96.                 } catch (IOException e) {
  97.                     e.printStackTrace();
  98.                 }
  99.             }
  100.             if(inputStream != null){
  101.                 try {
  102.                     inputStream.close();
  103.                 } catch (IOException e) {
  104.                     e.printStackTrace();
  105.                 }
  106.             }
  107.             if(outputStream != null){
  108.                 try {
  109.                     outputStream.close();
  110.                 } catch (IOException e) {
  111.                     e.printStackTrace();
  112.                 }
  113.             }
  114.             if(serverSocket != null){
  115.                 try {
  116.                     serverSocket.close();
  117.                 } catch (IOException e) {
  118.                     e.printStackTrace();
  119.                 }
  120.             }
  121.         }
  122.     }
  123. }

运行

服务端等待客户端的连接
image.png

客户端启动之后会等待服务端返回信息
image.png

服务端3s（手动设置的）之后，将返回成功的信息返回给客户端，客户端接收到信息之后打印到控制台，然后程序才会截止。
image.png