• 网络编程【TCP单向通信、TCP双向通信、一对多应用、一对多聊天服务器】(二)-全面详解（学习总结---从入门到深化）

     

     

    目录

    Java网络编程中的常用类

    TCP通信的实现和项目案例

    TCP通信入门案例 

    TCP单向通信

    TCP双向通信

    创建点对点的聊天应用

    一对多应用

    一对多聊天服务器

    Java网络编程中的常用类

    Java为了跨平台，在网络应用通信时是不允许直接调用操作系统接 口的，而是由java.net包来提供网络功能。下面我们来介绍几个 java.net包中的常用的类。

    InetAddress的使用 

    作用：封装计算机的IP地址和DNS（没有端口信息）

    注：DNS是Domain Name System，域名系统。

    特点：

    这个类没有构造方法。如果要得到对象，只能通过静态方法：

    getLocalHost()、getByName()、 getAllByName()、 getAddress()、getHostName()

     获取本机信息

    获取本机信息需要使用getLocalHost方法创建InetAddress对象。 getLocalHost()方法返回一个InetAddress对象，这个对象包含了本 机的IP地址，计算机名等信息。

    1. public class InetTest {
    2.     public static void main(String[] args)throws Exception {
    3.         //实例化InetAddress对象
    4.         InetAddress inetAddress = InetAddress.getLocalHost();
    5.         //返回当前计算机的IP地址
    6.       System.out.println(inetAddress.getHostAddress());
    7.         //返回当前计算机名
    8.       System.out.println(inetAddress.getHostName());
    9.    }
    10. }

    根据域名获取计算机的信息

    根据域名获取计算机信息时需要使用getByName(“域名”)方法创建 InetAddress对象。

    1. public class InetTest2 {
    2.     public static void main(String[] args)throws Exception {
    3.         InetAddress inetAddress = InetAddress.getByName("www.baidu.com");
    4.       System.out.println(inetAddress.getHostAddress());
    5.       System.out.println(inetAddress.getHostName());
    6.    }
    7. }

    根据IP获取计算机的信息

    根据IP地址获取计算机信息时需要使用getByName(“IP”)方法创建 InetAddress对象。

    1. public class InetTest3 {
    2.     public static void main(String[] args)throws  Exception {
    3.         InetAddress inetAddress = InetAddress.getByName("14.215.177.38");
    4.       System.out.println(inetAddress.getHostAddress());
    5.       System.out.println(inetAddress.getHostName());
    6.    }
    7. }

     InetSocketAddress的使用

    作用：包含IP和端口信息，常用于Socket通信。此类实现 IP 套接字 地址（IP 地址 + 端口号），不依赖任何协议。 InetSocketAddress相比较InetAddress多了一个端口号，端口的作 用：一台拥有IP地址的主机可以提供许多服务，比如Web服务、 FTP服务、SMTP服务等，这些服务完全可以通过1个IP地址来实 现。 那么，主机是怎样区分不同的网络服务呢？显然不能只靠IP地址， 因为IP 地址与网络服务的关系是一对多的关系。实际上是通过“IP地 址+端口号”来区分不同的服务的。

    1. public class InetSocketTest {
    2.     public static void main(String[] args) {
    3.         InetSocketAddress inetSocketAddress = new InetSocketAddress("www.baidu.com",80);
    4.       System.out.println(inetSocketAddress.getAddress().getHostAddress());
    5.       System.out.println(inetSocketAddress.getHostName());
    6.    }
    7. }

    URL的使用

    IP地址标识了Internet上唯一的计算机，而URL则标识了这些计算机 上的资源。 URL 代表一个统一资源定位符，它是指向互联网“资源” 的指针。资源可以是简单的文件或目录，也可以是对更为复杂的对 象的引用，例如对数据库或搜索引擎的查询。 为了方便程序员编程，JDK中提供了URL类，该类的全名是 java.net.URL，有了这样一个类，就可以使用它的各种方法来对 URL对象进行分割、合并等处理。

    1. public class UrlTest {
    2.     public static void main(String[] args)throws Exception {
    3.         URL url = new URL("https://www.itbaizhan.com/search.html?kw=java");
    4.         System.out.println("获取与此URL相关联协议的默认端口："+url.getDefaultPort());
    5.         System.out.println("访问资源："+url.getFile());
    6.         System.out.println("主机名"+url.getHost());
    7.         System.out.println("访问资源路径："+url.getPath());
    8.         System.out.println("协议："+url.getProtocol());
    9.         System.out.println("参数部分："+url.getQuery());
    10.    }
    11. }

     通过URL实现最简单的网络爬虫

    1. public class UrlTest2{
    2.     public static void main(String[] args)throws Exception {
    3.             URL url = new URL("https://www.itbaizhan.com/");
    4.             try (BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()))) {
    5.              StringBuilder sb = new StringBuilder();
    6.                 String temp;
    7.      /*
    8.       * 这样就可以将网络内容下载到本地机器。
    9.       * 然后进行数据分析，建立索引。这也是搜索引擎的第一步。
    10.       */
    11.                 while ((temp = br.readLine()) != null) {
    12.                     sb.append(temp);
    13.                }
    14.                 System.out.println(sb);
    15.            } catch (Exception e) {
    16.                 e.printStackTrace();
    17.            }
    18.    }
    19. }

    TCP通信的实现和项目案例

    TCP通信实现原理

    前边我们提到TCP协议是面向的连接的，在通信时客户端与服务器 端必须建立连接。在网络通讯中，第一次主动发起通讯的程序被称 作客户端(Client)程序，简称客户端，而在第一次通讯中等待连接的 程序被称作服务器端(Server)程序，简称服务器。一旦通讯建立，则 客户端和服务器端完全一样，没有本质的区别。

     “请求-响应”模式：

    Socket类：发送TCP消息。

    ServerSocket类：创建服务器。

     套接字Socket是一种进程间的数据交换机制。这些进程既可以在同 一机器上，也可以在通过网络连接的不同机器上。换句话说，套接 字起到通信端点的作用。单个套接字是一个端点，而一对套接字则 构成一个双向通信信道，使非关联进程可以在本地或通过网络进行 数据交换。一旦建立套接字连接，数据即可在相同或不同的系统中 双向或单向发送，直到其中一个端点关闭连接。套接字与主机地址 和端口地址相关联。主机地址就是客户端或服务器程序所在的主机 的IP地址。端口地址是指客户端或服务器程序使用的主机的通信端 口。 在客户端和服务器中，分别创建独立的Socket，并通过Socket的属 性，将两个Socket进行连接，这样，客户端和服务器通过套接字所 建立的连接使用输入输出流进行通信。 TCP/IP套接字是最可靠的双向流协议，使用TCP/IP可以发送任意数 量的数据。 实际上，套接字只是计算机上已编号的端口。如果发送方和接收方 计算机确定好端口，他们就可以通信了。 客户端与服务器端的通信关系图：

     

     TCP/IP通信连接的简单过程：

    位于A计算机上的TCP/IP软件向B计算机发送包含端口号的消息，B 计算机的TCP/IP软件接收该消息，并进行检查，查看是否有它知道 的程序正在该端口上接收消息。如果有，他就将该消息交给这个程 序。 要使程序有效地运行，就必须有一个客户端和一个服务器。

     通过Socket的编程顺序：

    1 创建服务器ServerSocket，在创建时，定义ServerSocket的监听端口（在这个端口接收客户端发来 的消息）

    2 ServerSocket调用accept()方法，使之处于阻塞状态。

    3 创建客户端Socket，并设置服务器的IP及端口。

    4 客户端发出连接请求，建立连接。

    5 分别取得服务器和客户端Socket的InputStream和OutputStream。

    6 利用Socket和ServerSocket进行数据传输。

    7 关闭流及Socket。

    TCP通信入门案例 

    创建服务端

    1. public class BasicSocketServer {
    2.     public static void main(String[] args) {
    3.         System.out.println("服务器启动等待监听。。。。");
    4.         //创建ServerSocket
    5.         try(ServerSocket ss =new ServerSocket(8888);
    6.             //监听8888端口，此时线程会处于阻塞状态。
    7.             Socket socket = ss.accept();
    8.             //连接成功后会得到与客户端对应的 Socket对象，并解除线程阻塞。
    9.            //通过客户端对应的Socket对象中的输入流对象，获取客户端发送过来的消息。
    10.             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()))
    11.        ){       
    12.             System.out.println(br.readLine());
    13.        }catch(Exception e){
    14.             e.printStackTrace();
    15.             System.out.println("服务器启动失败。。。。");
    16.        }
    17.    }
    18. }

    创建客户端

    1. public class BasicSocketClient {
    2.     public static void main(String[] args) {
    3.         //创建Socket对象
    4.         try(Socket socket =new Socket("127.0.01",8888);
    5.             //创建向服务端发送消息的输出流对象。
    6.             PrintWriter pw = new PrintWriter(socket.getOutputStream())){
    7.             pw.println("服务端，您好！");
    8.             pw.flush();
    9.        }catch(Exception e){
    10.             e.printStackTrace();
    11.        }
    12.    }
    13. }

    TCP单向通信

    单向通信是指通信双方中，一方固定为发送端，一方则固定为接收 端。

     创建服务端

    1. public class OneWaySocketServer {
    2.     public static void main(String[] args) {
    3.         System.out.println("服务端启动，开始监听。。。。。");
    4.         try(ServerSocket serverSocket = new ServerSocket(8888);
    5.             //监听8888端口，获与取客户端对应的 Socket对象
    6.             Socket socket = serverSocket.accept();
    7.             //通过与客户端对应的Socket对象获取输入流对象
    8.             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    9.             //通过与客户端对应的Socket对象获取输出流对象
    10.             PrintWriter pw = new PrintWriter(socket.getOutputStream())){
    11.             System.out.println("连接成功！");
    12.             while(true){
    13.                 //读取客户端发送的消息
    14.                 String str = br.readLine();
    15.                 System.out.println("客户端说："+str);
    16.                 if("exit".equals(str)){
    17.                     break;
    18.                }
    19.                 pw.println(str);
    20.                 pw.flush();
    21.            }
    22.        }catch(Exception e){
    23.             e.printStackTrace();
    24.             System.out.println("服务端启动失败。。。。。");
    25.        }
    26.    }
    27. }

    创建客户端

    1. public class OneWaySocketClient {
    2.     public static void main(String[] args) {
    3.         //获取与服务端对应的Socket对象
    4.         try(Socket socket = new Socket("127.0.0.1",8888);
    5.         //创建键盘输入对象
    6.             Scanner scanner = new Scanner(System.in);
    7.             //通过与服务端对应的Socket对象获取输出流对象
    8.             PrintWriter pw = new PrintWriter(socket.getOutputStream());
    9.             //通过与服务端对应的Socket对象获取输入流对象
    10.             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())))
    11.         {
    12.             while(true){
    13.                 //通过键盘输入获取需要向服务端发送的消息
    14.                 String str = scanner.nextLine();
    15.                 
    16.                 //将消息发送到服务端
    17.                 pw.println(str);
    18.                 pw.flush();
    19.                 if("exit".equals(str)){
    20.                     break;
    21.                }
    22.                 //读取服务端返回的消息
    23.                 String serverInput = br.readLine();
    24.                System.out.println("服务端返回的："+serverInput);
    25.            }
    26.        }catch(Exception e){
    27.             e.printStackTrace();
    28.        }
    29.    }
    30. }

    TCP双向通信

    双向通信是指通信双方中，任何一方都可为发送端，任何一方都可 为接收端。

    创建服务端

    1. public class TwoWaySocketServer {
    2.     public static void main(String[] args) {
    3.         System.out.println("服务端启动！监听端口8888。。。。");
    4.         try(ServerSocket serverSocket  = new ServerSocket(8888);
    5.             Socket socket = serverSocket.accept();
    6.             //创建键盘输入对象
    7.             Scanner scanner = new Scanner(System.in);
    8.             //通过与客户端对应的Socket对象获取输入流对象
    9.             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    10.             //通过与客户单对应的Socket对象获取输出流对象
    11.             PrintWriter pw  = new PrintWriter(socket.getOutputStream());){
    12.             while(true){
    13.                 //读取客户端发送的消息
    14.                 String str = br.readLine();
    15.                 System.out.println("客户端说："+str);
    16.                 String keyInput = scanner.nextLine();
    17.                 //发送到客户端
    18.                 pw.println(keyInput);
    19.                 pw.flush();
    20.            }
    21.        }catch(Exception e){
    22.             e.printStackTrace();
    23.        }
    24.    }
    25. }

    创建客户端

    1. public class TwoWaySocketClient {
    2.     public static void main(String[] args) {
    3.         try(Socket socket = new Socket("127.0.0.1", 8888);
    4.             //创建键盘输入对象
    5.             Scanner  scanner = new Scanner(System.in);
    6.             //通过与服务端对应的Socket对象获取输入流对象
    7.             BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    8.             //通过与服务端对应的Socket对象获取输出流对象
    9.             PrintWriter pw = new PrintWriter(socket.getOutputStream());){
    10.             while (true) {
    11.                 String keyInput = scanner.nextLine();
    12.                 pw.println(keyInput);
    13.                 pw.flush();
    14.                 String input = br.readLine();
    15.                 System.out.println("服务端说：" + input);
    16.            }
    17.        } catch (Exception e) {
    18.             e.printStackTrace();
    19.        }
    20.    }
    21. }

    创建点对点的聊天应用

    创建服务端

    1. /**
    2. * 发送消息线程
    3. */
    4. class Send extends Thread{
    5.     private Socket socket;
    6.     public Send(Socket socket){
    7.         this.socket = socket;
    8.    }
    9.     @Override
    10.     public void run() {
    11.         this.sendMsg();
    12.    }
    13.     /**
    14.      * 发送消息
    15.      */
    16.     private void sendMsg(){
    17.         //创建Scanner对象
    18.         try(Scanner scanner = new Scanner(System.in);
    19.             //创建向对方输出消息的流对象
    20.             PrintWriter pw = new PrintWriter(this.socket.getOutputStream());)
    21.           {
    22.             while(true){
    23.                 String msg = scanner.nextLine();
    24.                 pw.println(msg);
    25.                 pw.flush();
    26.            }
    27.        }catch(Exception e){
    28.             e.printStackTrace();
    29.        }
    30.    }
    31. }
    32. /**
    33. * 接收消息的线程
    34. */
    35. class Receive extends Thread{
    36.     private Socket socket;
    37.     public Receive(Socket socket){
    38.         this.socket = socket;
    39.    }
    40.     @Override
    41.     public void run() {
    42.         this.receiveMsg();
    43.    }
    44.     /**
    45.      * 用于接收对方消息的方法
    46.      */
    47.     private void receiveMsg(){
    48.         //创建用于接收对方发送消息的流对象
    49.         try(BufferedReader  br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));){
    50.             while(true){
    51.                     String msg = br.readLine();
    52.                     System.out.println("他说："+msg);
    53.            }
    54.        }catch(Exception e){
    55.             e.printStackTrace();
    56.        }
    57.    }
    58. }
    59. public class ChatSocketServer {
    60.     public static void main(String[] args) {
    61.         try(ServerSocket serverSocket = new ServerSocket(8888);){
    62.             System.out.println("服务端启动，等待连接。。。。。");
    63.             Socket socket = serverSocket.accept();
    64.             System.out.println("连接成功！");
    65.             new Send(socket).start();
    66.             new Receive(socket).start();
    67.        }catch(Exception e){
    68.             e.printStackTrace();
    69.        }
    70.    }
    71. }

    创建客户端

    1. /**
    2. * 用于发送消息的线程类
    3. */
    4. class ClientSend extends Thread{
    5.     private Socket socket;
    6.     public ClientSend(Socket socket){
    7.         this.socket = socket;
    8.    }
    9.     @Override
    10.     public void run() {
    11.         this.sendMsg();
    12.    }
    13.     /**
    14.      * 发送消息
    15.      */
    16.     private void sendMsg(){
    17.         //创建Scanner对象
    18.         try(Scanner scanner = new Scanner(System.in);
    19.             //创建向对方输出消息的流对象
    20.             PrintWriter pw = new PrintWriter(this.socket.getOutputStream());)
    21.             {
    22.             while(true){
    23.                 String msg = scanner.nextLine();
    24.                 pw.println(msg);
    25.                 pw.flush();
    26.            }
    27.        }catch(Exception e){
    28.             e.printStackTrace();
    29.        }
    30.    }
    31. }
    32. /**
    33. * 用于接收消息的线程类
    34. */
    35. class ClientReceive extends Thread{
    36.     private Socket socket;
    37.     public ClientReceive(Socket socket){
    38.         this.socket = socket;
    39.    }
    40.     @Override
    41.     public void run() {
    42.         this.receiveMsg();
    43.    }
    44.     /**
    45.      * 用于接收对方消息的方法
    46.      */
    47.     private void receiveMsg(){
    48.         //创建用于接收对方发送消息的流对象
    49.         try(BufferedReader br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));){
    50.             while(true){
    51.                 String msg = br.readLine();
    52.                 System.out.println("他说："+msg);
    53.            }
    54.        }catch(Exception e){
    55.             e.printStackTrace();
    56.        }
    57.    }
    58. }
    59. public class ChatSocketClient {
    60.     public static void main(String[] args) {
    61.         try {
    62.             Socket socket = new Socket("127.0.0.1", 8888);
    63.             System.out.println("连接成功！");
    64.             new ClientSend(socket).start();
    65.             new ClientReceive(socket).start();
    66.        }catch(Exception e){
    67.             e.printStackTrace();
    68.        }
    69.    }
    70. }

    优化点对点聊天应用

    1. /**
    2. * 发送消息线程
    3. */
    4. class Send extends Thread{
    5.     private Socket socket;
    6.     private Scanner scanner;
    7.     public Send(Socket socket,Scanner scanner){
    8.         this.socket = socket;
    9.         this.scanner = scanner;
    10. }
    11.     @Override
    12.     public void run() {
    13.         this.sendMsg();
    14.    }
    15.     /**
    16.      * 发送消息
    17.      */
    18.     private void sendMsg(){
    19.         //创建向对方输出消息的流对象
    20.         try(PrintWriter pw = new PrintWriter(this.socket.getOutputStream()))
    21. {
    22.             
    23.             while(true){
    24.                 String msg = scanner.nextLine();
    25.                 pw.println(msg);
    26.                 pw.flush();
    27.            }
    28.        }catch(Exception e){
    29.             e.printStackTrace();
    30.        }
    31.    }
    32. }
    33. /**
    34. * 接收消息的线程
    35. */
    36. class Receive extends Thread{
    37.     private Socket socket;
    38.   public Receive(Socket socket){
    39.         this.socket = socket;
    40.    }
    41.     @Override
    42.     public void run() {
    43.         this.receiveMsg();
    44.    }
    45.     /**
    46.      * 用于接收对方消息的方法
    47.      */
    48.     private void receiveMsg(){
    49.         //创建用于接收对方发送消息的流对象
    50.         try(BufferedReader br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()))){
    51.             while(true){
    52.                 String msg = br.readLine();
    53.                 System.out.println("他说："+msg);
    54.            }
    55.        }catch(Exception e){
    56.             e.printStackTrace();
    57.        }
    58.    }
    59. }
    60. public class GoodTCP {
    61.     public static void main(String[] args)
    62.       {
    63.         Scanner scanner = null;
    64.         ServerSocket serverSocket = null;
    65.         Socket socket = null;
    66.         try{
    67.             scanner = new Scanner(System.in);
    68.             System.out.println("请输入：server, 或者：,");
    69.             String str = scanner.nextLine();
    70.             String[] arr = str.split(",");
    71.             if("server".equals(arr[0])){
    72.                 //启动服务端
    73.                 System.out.println("TCP Server Listen at "+arr[1]+" .....");
    74.                 serverSocket = new ServerSocket(Integer.parseInt(arr[1]));
    75.                 socket = serverSocket.accept();
    76.                 System.out.println("连接成功！");
    77.            }else{
    78.                 //启动客户端
    79.                 socket = new Socket(arr[0],Integer.parseInt(arr[1]));
    80.                 System.out.println("连接成功！");
    81.            }
    82.             //启动发送消息的线程
    83.             new Send(socket,scanner).start();
    84.             //启动接收消息的线程
    85.          }catch(Exception e){
    86.             e.printStackTrace();
    87.        }finally{
    88.             if(serverSocket != null){
    89.                 try {
    90.                     serverSocket.close();
    91.                } catch (IOException e) {
    92.                     e.printStackTrace();
    93.                }
    94.            }
    95.        }
    96.    }
    97. }

    一对多应用

    一对多应用设计

    各socket对间独立问答，互相间不需要传递信息。

     一对多应答型服务器

    1. /**
    2. * 定义消息处理线程类
    3. */
    4. class Msg extends Thread{
    5.     private Socket socket;
    6.     public Msg(Socket socket){
    7.         this.socket = socket;
    8.    }
    9.     @Override
    10.     public void run() {
    11.         this.msg();
    12.    }
    13.     /**
    14.      * 将从客户端读取到的消息写回给客户端
    15.      */
    16.     private void msg(){
    17.         try(BufferedReader br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
    18.             PrintWriter pw = new PrintWriter(this.socket.getOutputStream())){
    19.             while(true){
    20.                 pw.println(br.readLine()+" [ok]");
    21.                 pw.flush();
    22.            }
    23.        }catch(Exception e){
    24.             e.printStackTrace();
    25.           System.out.println(this.socket.getInetAddress()+" 断线了！");
    26.        }
    27.    }
    28. }
    29. public class EchoServer {
    30.     public static void main(String[] args) {
    31.         try(ServerSocket serverSocket = new ServerSocket(8888)){
    32.             //等待多客户端连接
    33.             while(true){
    34.                 Socket socket = serverSocket.accept();
    35.                 new Msg(socket).start();
    36.            }
    37.        }catch(Exception e){
    38.             e.printStackTrace();
    39.        }
    40.    }
    41. }

    一对多聊天服务器

    服务器设计

    1、服务器的连接设计

    2、服务器的线程设计

     创建一对多聊天服务应用

    1. /**
    2. * 接收客户端消息的线程类
    3. */
    4. class ChatReceive extends Thread{
    5.     private Socket socket;
    6.     public ChatReceive(Socket socket){
    7.         this.socket =socket;
    8.    }
    9.     @Override
    10.     public void run() {
    11.         this.receiveMsg();
    12.    }
    13.     /**
    14.      * 实现接收客户端发送的消息
    15.      */
    16.     private void receiveMsg(){
    17.         try(BufferedReader br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()))){
    18.             while(true){
    19.                 String msg = br.readLine();
    20.                 synchronized ("abc"){
    21.                     //把读取到的数据写入公共数据区
    22.                     ChatRoomServer.buf=" ["+this.socket.getInetAddress()+"] "+msg;
    23.                     //唤醒发送消息的线程对象。
    24.                     "abc".notifyAll();
    25.                }
    26.            }
    27.        }catch(Exception e){
    28.             e.printStackTrace();
    29.        }
    30.    }
    31. }
    32. /**
    33. * 向客户端发送消息的线程类
    34. */
    35. class ChatSend extends Thread{
    36.     private Socket socket;
    37.     public ChatSend(Socket socket){
    38.         this.socket = socket;
    39.    }
    40.     @Override
    41.     public void run() {
    42.         this.sendMsg();
    43.    }
    44.     /**
    45.      * 将公共数据区的消息发送给客户端
    46.      */
    47.     private void sendMsg(){
    48.         try(PrintWriter  pw = new PrintWriter(this.socket.getOutputStream())){
    49.             while(true){
    50.                 synchronized ("abc"){
    51.                     //让发送消息的线程处于等待状态
    52.                     "abc".wait();
    53.                     //将公共数据区中的消息发送给客户端
    54.                     pw.println(ChatRoomServer.buf);
    55.                     pw.flush();
    56.                }
    57.            }
    58.        }catch(Exception e){
    59.             e.printStackTrace();
    60.        }
    61.    }
    62. }
    63. public class ChatRoomServer {
    64.     //定义公共数据区
    65.     public static String buf;
    66.     public static void main(String[] args) {
    67.         System.out.println("Chat Server Version 1.0");
    68.         System.out.println("Listen at 8888.....");
    69.         try(ServerSocket serverSocket = new ServerSocket(8888)){
    70.             while(true){
    71.                 Socket socket = serverSocket.accept();
    72.                 System.out.println("连接到："+socket.getInetAddress());
    73.                 new ChatReceive(socket).start();
    74.                 new ChatSend(socket).start();
    75.            }
    76.        }catch(Exception e){
    77.             e.printStackTrace();
    78.        }
    79.    }
    80. }
  • 相关阅读:
    Vue进阶（幺陆玖）信创适配改造
    JS原生-弹框+阿里巴巴矢量图
    嵌入式Linux 开发经验：内核驱动静态编译与模块编译
    Gateway之限流、熔断，Sentinel--服务容错
    你所不知道的 vscode，汇集历史版本中你可能不知道的新特性
    让你全方位了解Shell终端，轻松学习
    Doris 5 处理Sentinel-1 生成干涉图 interferogram
    小白学爬虫：通过关键词搜索1688商品列表数据接口|1688商品列表数据接口|1688商品列表数据采集|1688API接口
    OSError: Can‘t load tokenizer for ‘bert-base-chinese‘
    一次Python本地cache不当使用导致的内存泄露
  • 原文地址：https://blog.csdn.net/m0_58719994/article/details/131669344