• Java之TCP,UDP综合小练习一

    4. 综合练习

    练习一：多发多收

    需求：

    客户端：多次发送数据

    服务器：接收多次接收数据，并打印

    代码示例：

    1. public class Client {
    2.     public static void main(String[] args) throws IOException {
    3.         //客户端：多次发送数据
    4.         //服务器：接收多次接收数据，并打印
    5. ​
    6.         //1. 创建Socket对象并连接服务端
    7.         Socket socket = new Socket("127.0.0.1",10000);
    8. ​
    9.         //2.写出数据
    10.         Scanner sc = new Scanner(System.in);
    11.         OutputStream os = socket.getOutputStream();
    12. ​
    13.         while (true) {
    14.             System.out.println("请输入您要发送的信息");
    15.             String str = sc.nextLine();
    16.             if("886".equals(str)){
    17.                 break;
    18.             }
    19.             os.write(str.getBytes());
    20.         }
    21.         //3.释放资源
    22.         socket.close();
    23.     }
    24. }
    25. public class Server {
    26.     public static void main(String[] args) throws IOException {
    27.         //客户端：多次发送数据
    28.         //服务器：接收多次接收数据，并打印
    29. ​
    30.         //1.创建对象绑定10000端口
    31.         ServerSocket ss = new ServerSocket(10000);
    32. ​
    33.         //2.等待客户端来连接
    34.         Socket socket = ss.accept();
    35. ​
    36.         //3.读取数据
    37.         InputStreamReader isr = new InputStreamReader(socket.getInputStream());
    38.         int b;
    39.         while ((b = isr.read()) != -1){
    40.             System.out.print((char)b);
    41.         }
    42. ​
    43.         //4.释放资源
    44.         socket.close();
    45.         ss.close();
    46.     }
    47. }

    练习二：接收并反馈

    • 案例需求

      客户端：发送数据，接受服务器反馈

      服务器：收到消息后给出反馈

    • 案例分析

      • 客户端创建对象，使用输出流输出数据

      • 服务端创建对象，使用输入流接受数据

      • 服务端使用输出流给出反馈数据

      • 客户端使用输入流接受反馈数据

    • 代码实现

      1. // 客户端
      2. public class ClientDemo {
      3.     public static void main(String[] args) throws IOException {
      4.         Socket socket = new Socket("127.0.0.1",10000);
      5. ​
      6.         OutputStream os = socket.getOutputStream();
      7.         os.write("hello".getBytes());
      8.        // os.close();如果在这里关流,会导致整个socket都无法使用
      9.         socket.shutdownOutput();//仅仅关闭输出流.并写一个结束标记,对socket没有任何影响
      10.         
      11.         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
      12.         String line;
      13.         while((line = br.readLine())!=null){
      14.             System.out.println(line);
      15.         }
      16.         br.close();
      17.         os.close();
      18.         socket.close();
      19.     }
      20. }
      21. // 服务器
      22. public class ServerDemo {
      23.     public static void main(String[] args) throws IOException {
      24.         ServerSocket ss = new ServerSocket(10000);
      25. ​
      26.         Socket accept = ss.accept();
      27. ​
      28.         InputStream is = accept.getInputStream();
      29.         int b;
      30.         while((b = is.read())!=-1){
      31.             System.out.println((char) b);
      32.         }
      33. ​
      34.         System.out.println("看看我执行了吗?");
      35. ​
      36.         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
      37.         bw.write("你谁啊?");
      38.         bw.newLine();
      39.         bw.flush();
      40. ​
      41.         bw.close();
      42.         is.close();
      43.         accept.close();
      44.         ss.close();
      45.     }
      46. }

    练习三：上传练习（TCP协议）

    • 案例需求

      客户端：数据来自于本地文件，接收服务器反馈

      服务器：接收到的数据写入本地文件，给出反馈

    • 案例分析

      • 创建客户端对象，创建输入流对象指向文件，每读一次数据就给服务器输出一次数据，输出结束后使用shutdownOutput()方法告知服务端传输结束

      • 创建服务器对象，创建输出流对象指向文件，每接受一次数据就使用输出流输出到文件中，传输结束后。使用输出流给客户端反馈信息

      • 客户端接受服务端的回馈信息

    • 相关方法

      方法名说明
      void shutdownInput()将此套接字的输入流放置在“流的末尾”
      void shutdownOutput()禁止用此套接字的输出流

    • 代码实现

      1. public class Client {
      2.     public static void main(String[] args) throws IOException {
      3.         //客户端：将本地文件上传到服务器。接收服务器的反馈。
      4.         //服务器：接收客户端上传的文件，上传完毕之后给出反馈。
      5. ​
      6. ​
      7.         //1. 创建Socket对象，并连接服务器
      8.         Socket socket = new Socket("127.0.0.1",10000);
      9. ​
      10.         //2.读取本地文件中的数据，并写到服务器当中
      11.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("mysocketnet\\clientdir\\a.jpg"));
      12.         BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
      13.         byte[] bytes = new byte[1024];
      14.         int len;
      15.         while ((len = bis.read(bytes)) != -1){
      16.             bos.write(bytes,0,len);
      17.         }
      18. ​
      19.         //往服务器写出结束标记
      20.         socket.shutdownOutput();
      21. ​
      22. ​
      23.         //3.接收服务器的回写数据
      24.         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
      25.         String line = br.readLine();
      26.         System.out.println(line);
      27. ​
      28. ​
      29.         //4.释放资源
      30.         socket.close();
      31. ​
      32.     }
      33. }
      34. public class Server {
      35.     public static void main(String[] args) throws IOException {
      36.         //客户端：将本地文件上传到服务器。接收服务器的反馈。
      37.         //服务器：接收客户端上传的文件，上传完毕之后给出反馈。
      38. ​
      39. ​
      40.         //1.创建对象并绑定端口
      41.         ServerSocket ss = new ServerSocket(10000);
      42. ​
      43.         //2.等待客户端来连接
      44.         Socket socket = ss.accept();
      45. ​
      46.         //3.读取数据并保存到本地文件中
      47.         BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
      48.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("mysocketnet\\serverdir\\a.jpg"));
      49.         int len;
      50.         byte[] bytes = new byte[1024];
      51.         while ((len = bis.read(bytes)) != -1){
      52.             bos.write(bytes,0,len);
      53.         }
      54.         bos.close();
      55.         //4.回写数据
      56.         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
      57.         bw.write("上传成功");
      58.         bw.newLine();
      59.         bw.flush();
      60. ​
      61.         //5.释放资源
      62.         socket.close();
      63.         ss.close();
      64.     }
      65. }

    练习四：文件名重复

     ```java
    1. public class UUIDTest { public static void main(String[] args) { String str = UUID.randomUUID().toString().replace("-", ""); System.out.println(str);//9f15b8c356c54f55bfcb0ee3023fce8a } } ```
    2.  
    3. public class Client {
    4.     public static void main(String[] args) throws IOException {
    5.         //客户端：将本地文件上传到服务器。接收服务器的反馈。
    6.         //服务器：接收客户端上传的文件，上传完毕之后给出反馈。
    7. ​
    8. ​
    9.         //1. 创建Socket对象，并连接服务器
    10.         Socket socket = new Socket("127.0.0.1",10000);
    11. ​
    12.         //2.读取本地文件中的数据，并写到服务器当中
    13.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("mysocketnet\\clientdir\\a.jpg"));
    14.         BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
    15.         byte[] bytes = new byte[1024];
    16.         int len;
    17.         while ((len = bis.read(bytes)) != -1){
    18.             bos.write(bytes,0,len);
    19.         }
    20. ​
    21.         //往服务器写出结束标记
    22.         socket.shutdownOutput();
    23. ​
    24. ​
    25.         //3.接收服务器的回写数据
    26.         BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    27.         String line = br.readLine();
    28.         System.out.println(line);
    29. ​
    30. ​
    31.         //4.释放资源
    32.         socket.close();
    33. ​
    34.     }
    35. }
    36. public class Server {
    37.     public static void main(String[] args) throws IOException {
    38.         //客户端：将本地文件上传到服务器。接收服务器的反馈。
    39.         //服务器：接收客户端上传的文件，上传完毕之后给出反馈。
    40. ​
    41. ​
    42.         //1.创建对象并绑定端口
    43.         ServerSocket ss = new ServerSocket(10000);
    44. ​
    45.         //2.等待客户端来连接
    46.         Socket socket = ss.accept();
    47. ​
    48.         //3.读取数据并保存到本地文件中
    49.         BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
    50.         String name = UUID.randomUUID().toString().replace("-", "");
    51.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("mysocketnet\\serverdir\\" + name + ".jpg"));
    52.         int len;
    53.         byte[] bytes = new byte[1024];
    54.         while ((len = bis.read(bytes)) != -1) {
    55.             bos.write(bytes, 0, len);
    56.         }
    57.         bos.close();
    58.         //4.回写数据
    59.         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    60.         bw.write("上传成功");
    61.         bw.newLine();
    62.         bw.flush();
    63. ​
    64.         //5.释放资源
    65.         socket.close();
    66.         ss.close();
    67.     }

  • 相关阅读:
    设计模式教程
    李宏毅2022《机器学习/深度学习》——学习笔记（5）
    Obsidian配置
    视频讲解vue2基础之style样式class类名绑定
    java文件命令行报错: 找不到或无法加载主类XXX报错及解决
    计算机能转嵌入式吗？
    Chapter9.2：线性系统的状态空间分析与综合(上)
    智联汽车 — 自动/辅助驾驶技术
    算法竞赛进阶指南 0x65 负环与差分约数
    破局数据分析滞后难题，赋能企业高速增长的指标管理解决方案
  • 原文地址：https://blog.csdn.net/qq_69748833/article/details/133660474