devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java基础——TCP通信_java tcp

作者：Cpp五条 | 2024-06-11 18:26:56

赞

踩

java tcp

（1）TCP协议特点：

  • TCP是一种面向连接，安全，可靠的传输数据的协议
  • 传输前，采用“三次握手”方式，点对点通信，是可靠的
  • 在连接中可进行大数据量的传输

（2） TCP通信模式：（在java中只需使用java.net.Socket类实现通信，底层即是使用了TCP协议）

2.1：一发一收

客户端 （一发一收）

  1. import java.io.OutputStream;
  2. import java.io.PrintStream;
  3. import java.net.Socket;
  4.  
  5. /**
  6.    目标：完成Socket网络编程入门案例的客户端开发，实现1发1收。
  7.  */
  8. public class ClientDemo1 {
  9.     public static void main(String[] args) {
  10.         try {
  11.             System.out.println("====客户端启动===");
  12.             // 1、创建Socket通信管道请求有服务端的连接
  13.             // public Socket(String host, int port)
  14.             // 参数一：服务端的IP地址
  15.             // 参数二：服务端的端口
  16.             Socket socket = new Socket("127.0.0.1", 7777);
  17.  
  18.             // 2、从socket通信管道中得到一个字节输出流 负责发送数据
  19.             OutputStream os = socket.getOutputStream();
  20.  
  21.             // 3、把低级的字节流包装成打印流
  22.             PrintStream ps = new PrintStream(os);
  23.  
  24.             // 4、发送消息
  25.             ps.println("我是TCP的客户端，我已经与你对接，并发出邀请：约吗？");
  26.             ps.flush();
  27.  
  28.             // 关闭资源。
  29.             // socket.close();
  30.  
  31.         } catch (Exception e) {
  32.             e.printStackTrace();
  33.         }
  34.     }
  35. }

服务端（一发一收）

  1. import java.io.BufferedReader;
  2. import java.io.InputStream;
  3. import java.io.InputStreamReader;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6.  
  7. /**
  8.    目标：开发Socket网络编程入门代码的服务端，实现接收消息
  9.  */
  10. public class ServerDemo2 {
  11.     public static void main(String[] args) {
  12.         try {
  13.             System.out.println("===服务端启动成功===");
  14.             // 1、注册端口
  15.             ServerSocket serverSocket = new ServerSocket(7777);
  16.             // 2、必须调用accept方法：等待接收客户端的Socket连接请求，建立Socket通信管道
  17.             Socket socket = serverSocket.accept();
  18.             // 3、从socket通信管道中得到一个字节输入流
  19.             InputStream is = socket.getInputStream();
  20.             // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
  21.             BufferedReader br = new BufferedReader(new InputStreamReader(is));
  22.             // 5、按照行读取消息
  23.             String msg;
  24.             if ((msg = br.readLine()) != null){
  25.                 System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
  26.             }
  27.         } catch (Exception e) {
  28.             e.printStackTrace();
  29.         }
  30.     }
  31. }

2.2：多发多收（单线程）

注意：目前的服务端不可以同时接收多个客户端的信息，因为目前服务端现在只有一个线程，只能与一个客户端进行通信。

客户端（多发多收：单线程，使用循环反复地发送消息）

  1. import java.io.OutputStream;
  2. import java.io.PrintStream;
  3. import java.net.Socket;
  4. import java.util.Scanner;
  5.  
  6. /**
  7.    目标：实现多发和多收
  8.  */
  9. public class ClientDemo1 {
  10.     public static void main(String[] args) {
  11.         try {
  12.             System.out.println("====客户端启动===");
  13.             // 1、创建Socket通信管道请求有服务端的连接
  14.             // public Socket(String host, int port)
  15.             // 参数一：服务端的IP地址
  16.             // 参数二：服务端的端口
  17.             Socket socket = new Socket("127.0.0.1", 7777);
  18.  
  19.             // 2、从socket通信管道中得到一个字节输出流 负责发送数据
  20.             OutputStream os = socket.getOutputStream();
  21.  
  22.             // 3、把低级的字节流包装成打印流
  23.             PrintStream ps = new PrintStream(os);
  24.  
  25.             Scanner sc =  new Scanner(System.in);
  26.             while (true) {
  27.                 System.out.println("请说：");
  28.                 String msg = sc.nextLine();
  29.                 // 4、发送消息
  30.                 ps.println(msg);
  31.                 ps.flush();
  32.             }
  33.  
  34.             // 关闭资源。
  35.             // socket.close();
  36.  
  37.         } catch (Exception e) {
  38.             e.printStackTrace();
  39.         }
  40.     }
  41. }

服务端（多发多收：单线程，使用循环反复的接收消息）

  1. import java.io.BufferedReader;
  2. import java.io.InputStream;
  3. import java.io.InputStreamReader;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6.  
  7. /**
  8.    目标：开发Socket网络编程入门代码的服务端，实现接收消息
  9.  */
  10. public class ServerDemo2 {
  11.     public static void main(String[] args) {
  12.         try {
  13.             System.out.println("===服务端启动成功===");
  14.             // 1、注册端口
  15.             ServerSocket serverSocket = new ServerSocket(7777);
  16.             while (true) {
  17.                 // 2、必须调用accept方法：等待接收客户端的Socket连接请求，建立Socket通信管道
  18.                 Socket socket = serverSocket.accept();
  19.                 // 3、从socket通信管道中得到一个字节输入流
  20.                 InputStream is = socket.getInputStream();
  21.                 // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
  22.                 BufferedReader br = new BufferedReader(new InputStreamReader(is));
  23.                 // 5、按照行读取消息
  24.                 String msg;
  25.                 while ((msg = br.readLine()) != null){
  26.                     System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
  27.                 }
  28.             }
  29.         } catch (Exception e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  33. }

2.3：多发多收（多线程）

客户端（多发多收：多线程） 

  1. import java.io.OutputStream;
  2. import java.io.PrintStream;
  3. import java.net.Socket;
  4. import java.util.Scanner;
  5.  
  6. /**
  7.     目标：实现服务端可以同时处理多个客户端的消息。
  8.  */
  9. public class ClientDemo3 {
  10.     public static void main(String[] args) {
  11.         try {
  12.             System.out.println("====客户端启动===");
  13.             // 1、创建Socket通信管道请求有服务端的连接
  14.             // public Socket(String host, int port)
  15.             // 参数一：服务端的IP地址
  16.             // 参数二：服务端的端口
  17.             Socket socket = new Socket("127.0.0.1", 7777);
  18.  
  19.             // 2、从socket通信管道中得到一个字节输出流 负责发送数据
  20.             OutputStream os = socket.getOutputStream();
  21.  
  22.             // 3、把低级的字节流包装成打印流
  23.             PrintStream ps = new PrintStream(os);
  24.  
  25.             Scanner sc =  new Scanner(System.in);
  26.             while (true) {
  27.                 System.out.println("请说：");
  28.                 String msg = sc.nextLine();
  29.                 // 4、发送消息
  30.                 ps.println(msg);
  31.                 ps.flush();
  32.             }
  33.  
  34.             // 关闭资源。
  35.             // socket.close();
  36.  
  37.         } catch (Exception e) {
  38.             e.printStackTrace();
  39.         }
  40.     }
  41. }

服务端（多发多收：多线程） 

  1. import java.net.ServerSocket;
  2. import java.net.Socket;
  3.  
  4. /**
  5.    目标：实现服务端可以同时处理多个客户端的消息。
  6.  */
  7. public class ServerDemo3 {
  8.     public static void main(String[] args) {
  9.         try {
  10.             System.out.println("===服务端启动成功===");
  11.             // 1、注册端口
  12.             ServerSocket serverSocket = new ServerSocket(7777);
  13.             // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
  14.             while (true) {
  15.                 // 2、每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
  16.                 Socket socket = serverSocket.accept();
  17.                 System.out.println(socket.getRemoteSocketAddress()+ "它来了，上线了！");
  18.                 // 3、开始创建独立线程处理socket
  19.                 new ServerReaderThread(socket).start();
  20.             }
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.         }
  24.     }
  25. }

（定义一个线程类）

  1. import java.io.BufferedReader;
  2. import java.io.InputStream;
  3. import java.io.InputStreamReader;
  4. import java.net.Socket;
  5.  
  6. public class ServerReaderThread extends Thread{
  7.     private Socket socket;
  8.     public ServerReaderThread(Socket socket){
  9.         this.socket = socket;
  10.     }
  11.     @Override
  12.     public void run() {
  13.         try {
  14.             // 3、从socket通信管道中得到一个字节输入流
  15.             InputStream is = socket.getInputStream();
  16.             // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
  17.             BufferedReader br = new BufferedReader(new InputStreamReader(is));
  18.             // 5、按照行读取消息
  19.             String msg;
  20.             while ((msg = br.readLine()) != null){
  21.                 System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
  22.             }
  23.         } catch (Exception e) {
  24.             System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
  25.         }
  26.     }
  27. }

2.4：线程池

服务端可以复用线程处理多个客户端，可以避免系统瘫痪。

适合客户端通信时长较短的场景。

客户端（线程池：处理多个客户端消息，解决多线程N-N的关系，导致资源浪费的问题）

  1. import java.io.OutputStream;
  2. import java.io.PrintStream;
  3. import java.net.Socket;
  4. import java.util.Scanner;
  5.  
  6. /**
  7.     拓展：使用线程池优化：实现通信。
  8.  */
  9. public class ClientDemo4 {
  10.     public static void main(String[] args) {
  11.         try {
  12.             System.out.println("====客户端启动===");
  13.             // 1、创建Socket通信管道请求有服务端的连接
  14.             // public Socket(String host, int port)
  15.             // 参数一：服务端的IP地址
  16.             // 参数二：服务端的端口
  17.             Socket socket = new Socket("127.0.0.1", 6666);
  18.  
  19.             // 2、从socket通信管道中得到一个字节输出流 负责发送数据
  20.             OutputStream os = socket.getOutputStream();
  21.  
  22.             // 3、把低级的字节流包装成打印流
  23.             PrintStream ps = new PrintStream(os);
  24.  
  25.             Scanner sc =  new Scanner(System.in);
  26.             while (true) {
  27.                 System.out.println("请说：");
  28.                 String msg = sc.nextLine();
  29.                 // 4、发送消息
  30.                 ps.println(msg);
  31.                 ps.flush();
  32.             }
  33.             // 关闭资源。
  34.             // socket.close();
  35.  
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.         }
  39.     }
  40. }

 2.8服务端（线程池：处理多个客户端消息，解决多线程N-N的关系，导致资源浪费的问题）

  1. import java.net.ServerSocket;
  2. import java.net.Socket;
  3. import java.util.concurrent.*;
  4.  
  5. /**
  6.    目标：实现服务端可以同时处理多个客户端的消息。
  7.  */
  8. public class ServerDemo4 {
  9.  
  10.     // 使用静态变量记住一个线程池对象
  11.     private static ExecutorService pool = new ThreadPoolExecutor(300,
  12.             1500, 6, TimeUnit.SECONDS,
  13.             new ArrayBlockingQueue<>(2)
  14.     , Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
  15.  
  16.     public static void main(String[] args) {
  17.         try {
  18.             System.out.println("===服务端启动成功===");
  19.             // 1、注册端口
  20.             ServerSocket serverSocket = new ServerSocket(6666);
  21.             // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
  22.             while (true) {
  23.                 // 2、每接收到一个客户端的Socket管道，
  24.                 Socket socket = serverSocket.accept();
  25.                 System.out.println(socket.getRemoteSocketAddress()+ "它来了，上线了！");
  26.  
  27.                 // 任务对象负责读取消息。
  28.                 Runnable target = new ServerReaderRunnable(socket);
  29.                 pool.execute(target);
  30.             }
  31.         } catch (Exception e) {
  32.             e.printStackTrace();
  33.         }
  34.     }
  35. }

（定义一个任务类） 

  1. import java.io.BufferedReader;
  2. import java.io.InputStream;
  3. import java.io.InputStreamReader;
  4. import java.net.Socket;
  5.  
  6. public class ServerReaderRunnable implements Runnable{
  7.     private Socket socket;
  8.     public ServerReaderRunnable(Socket socket){
  9.         this.socket = socket;
  10.     }
  11.     @Override
  12.     public void run() {
  13.         try {
  14.             // 3、从socket通信管道中得到一个字节输入流
  15.             InputStream is = socket.getInputStream();
  16.             // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
  17.             BufferedReader br = new BufferedReader(new InputStreamReader(is));
  18.             // 5、按照行读取消息
  19.             String msg;
  20.             while ((msg = br.readLine()) != null){
  21.                 System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
  22.             }
  23.         } catch (Exception e) {
  24.             System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
  25.         }
  26.     }
  27. }

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号