• Java之UDP,TCP的详细解析

    练习四：文件名重复

    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.     }
    68. }

    练习五：服务器改写为多线程

    服务器只能处理一个客户端请求，接收完一个图片之后，服务器就关闭了。

    优化方案一：

    使用循环

    弊端：

    第一个用户正在上传数据，第二个用户就来访问了，此时第二个用户是无法成功上传的。

    所以，使用多线程改进

    优化方案二：

    每来一个用户，就开启多线程处理

    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.         while (true) {
    44.             //2.等待客户端来连接
    45.             Socket socket = ss.accept();
    46. ​
    47.             //开启一条线程
    48.             //一个用户就对应服务端的一条线程
    49.             new Thread(new MyRunnable(socket)).start();
    50.         }
    51. ​
    52.     }
    53. }
    54. ​
    55. ​
    56. public class MyRunnable implements Runnable{
    57. ​
    58.     Socket socket;
    59. ​
    60.     public MyRunnable(Socket socket){
    61.         this.socket = socket;
    62.     }
    63. ​
    64.     @Override
    65.     public void run() {
    66.         try {
    67.             //3.读取数据并保存到本地文件中
    68.             BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
    69.             String name = UUID.randomUUID().toString().replace("-", "");
    70.             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("mysocketnet\\serverdir\\" + name + ".jpg"));
    71.             int len;
    72.             byte[] bytes = new byte[1024];
    73.             while ((len = bis.read(bytes)) != -1) {
    74.                 bos.write(bytes, 0, len);
    75.             }
    76.             bos.close();
    77.             //4.回写数据
    78.             BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    79.             bw.write("上传成功");
    80.             bw.newLine();
    81.             bw.flush();
    82.         } catch (IOException e) {
    83.             e.printStackTrace();
    84.         } finally {
    85.             //5.释放资源
    86.            if(socket != null){
    87.                try {
    88.                    socket.close();
    89.                } catch (IOException e) {
    90.                    e.printStackTrace();
    91.                }
    92.            }
    93.         }
    94.     }
    95. }

    练习六：线程池改进

    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.         //创建线程池对象
    41.         ThreadPoolExecutor pool = new ThreadPoolExecutor(
    42.                 3,//核心线程数量
    43.                 16,//线程池总大小
    44.                 60,//空闲时间
    45.                 TimeUnit.SECONDS,//空闲时间（单位）
    46.                 new ArrayBlockingQueue<>(2),//队列
    47.                 Executors.defaultThreadFactory(),//线程工厂，让线程池如何创建线程对象
    48.                 new ThreadPoolExecutor.AbortPolicy()//阻塞队列
    49.         );
    50. ​
    51. ​
    52. ​
    53.         //1.创建对象并绑定端口
    54.         ServerSocket ss = new ServerSocket(10000);
    55. ​
    56.         while (true) {
    57.             //2.等待客户端来连接
    58.             Socket socket = ss.accept();
    59. ​
    60.             //开启一条线程
    61.             //一个用户就对应服务端的一条线程
    62.             //new Thread(new MyRunnable(socket)).start();
    63.             pool.submit(new MyRunnable(socket));
    64.         }
    65. ​
    66.     }
    67. }
    68. public class MyRunnable implements Runnable{
    69. ​
    70.     Socket socket;
    71. ​
    72.     public MyRunnable(Socket socket){
    73.         this.socket = socket;
    74.     }
    75. ​
    76.     @Override
    77.     public void run() {
    78.         try {
    79.             //3.读取数据并保存到本地文件中
    80.             BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
    81.             String name = UUID.randomUUID().toString().replace("-", "");
    82.             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("mysocketnet\\serverdir\\" + name + ".jpg"));
    83.             int len;
    84.             byte[] bytes = new byte[1024];
    85.             while ((len = bis.read(bytes)) != -1) {
    86.                 bos.write(bytes, 0, len);
    87.             }
    88.             bos.close();
    89.             //4.回写数据
    90.             BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    91.             bw.write("上传成功");
    92.             bw.newLine();
    93.             bw.flush();
    94.         } catch (IOException e) {
    95.             e.printStackTrace();
    96.         } finally {
    97.             //5.释放资源
    98.            if(socket != null){
    99.                try {
    100.                    socket.close();
    101.                } catch (IOException e) {
    102.                    e.printStackTrace();
    103.                }
    104.            }
    105.         }
    106.     }
    107. }
  • 相关阅读:
    【数据结构】测试4 串
    java114-Calendar类方法before
    无人机航测没信号？北斗卫星来解决
    【Linux内核系列】进程调度
    状态机的技术选型看这篇就够了,最后一个直叫好！！！
    webstorm 去除注释空格
    快捷输入法怎么设置
    ICSFUZZ:操纵I/O、二进制代码重用以及插桩，来Fuzzing工业控制应用程序
    Llama2 论文中译版——开放式基础和微调聊天模型
    Linux- 使用ssh远程连接
  • 原文地址：https://blog.csdn.net/qq_69748833/article/details/133692095