网络编程套接字之TCP

蔚落 2023-09-27 14:09 91阅读 0赞

![在这里插入图片描述][a70b7959025f49f6b318dae821551d2f.gif_pic_center]

#### 文章目录 ####

*  一、TCP流套接字编程
 *   *  ServerSocket
     *  Socket
     *  TCP长短连接
 *  二、TCP回显服务器客户端
 *   *  服务器
     *  客户端
     *  并发服务器
     *  UDP与TCP

## 一、TCP流套接字编程 ##

我们来一起学习一下TCP socket api的使用，这个api与我们之前学习的IO流操作紧密相关，如果对IO流还不太熟悉的，可以看看这篇[IO流操作][IO]

### ServerSocket ###

顾名思义，ServerSocket是创建TCP服务器的Socket对象

<table> 
 <thead> 
  <tr> 
   <th>构造方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ServerSocket(int port)</td> 
   <td>创建一个服务器套接字Socket，并指定端口号</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Socket accept()</td> 
   <td>开始监听指定端口，有客户端连接时，返回一个服务端Socket对象，并基于该Socket对象与客户端建立连接，否则阻塞等待</td> 
  </tr> 
  <tr> 
   <td>void close()</td> 
   <td>关闭此套接字</td> 
  </tr> 
 </tbody> 
</table>

### Socket ###

我们这里的Socket既是客户端的Socket，也可能是服务器接收到客户端连接后，返回的服务器Socket，不论是那个Socket，都是双方建立连接后，保存对方信息，进行收发数据的。

<table> 
 <thead> 
  <tr> 
   <th>构造方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Socket(String host,int port)</td> 
   <td>创建一个客户端Socket对象，并与对应IP主机，对应端口的进程进行连接</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>InetAddress getInetAddress()</td> 
   <td>返回套接字所连接的地址</td> 
  </tr> 
  <tr> 
   <td>InputStream getInputStream()</td> 
   <td>返回套接字的输入流</td> 
  </tr> 
  <tr> 
   <td>OutputStream getOutputStream()</td> 
   <td>返回套接字的输出流</td> 
  </tr> 
 </tbody> 
</table>

### TCP长短连接 ###

顾名思义，我们的TCP的长短连接，就表示我们TCP建立连接后，什么时候关闭连接就决定了是长连接还是短链接。  
**短连接：** 在每次接收到数据并返回响应后，关闭连接。也就是说短连接只能收发一次数据。  
**长连接：** 一直保持连接的状态，不关闭连接，双方可以不停的收发数据。

两者各有优缺，短连接适用于客户端请求频率不高的场景，浏览网页等。长连接适用于客户端与服务器频繁通信的场景，视频通话等。

## 二、TCP回显服务器客户端 ##

### 服务器 ###

有了昨天UDP实现的基础，今天我们的TCP实现已经有些部分就比较容易理解了。

public class EchoServer {
        
        private ServerSocket serverSocket = null;
        
        public EchoServer(int port) throws IOException {
        
            serverSocket = new ServerSocket(port);
        }
    }

先创建TCP服务器Socket对象，并指定端口号。

Socket clientSocket = serverSocket.accept();

与客户端进行连接，如果没有获取到连接，则会发生阻塞等待，每获取到一个客户端连接就会返回一个Socket对象，该Socket对象是专门负责与连接的客户端进行通信的。  
我们获取到的每一个Socket对象，可能会进行多次通信，所以我们获取到连接后，将通信封装成一个方法。

private void processCoonection(Socket clientSocket) {
        
            System.out.printf("[%s:%d] 客户端上线\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
            try(InputStream inputStream = clientSocket.getInputStream();
                OutputStream outputStream = clientSocket.getOutputStream()) {
        
                
            }catch (IOException e) {
        
                e.printStackTrace();
            }finally {
        
                try{
        
                    clientSocket.close();
                }catch (IOException e) {
        
                    e.printStackTrace();
                }
            }
        }

我们先获取与输出输入流，因为需要释放我们直接将它们放到try()中，然后在finally里释放Socket对象资源。

Scanner scanner = new Scanner(inputStream);
                    if(!scanner.hasNext()) {
        
                        //数据已经读完了
                        System.out.printf("[%s:%d] 客户端下线\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                        break;
                    }
                    String request = scanner.next();

我们将输入流封装到Scanner里，从控制台输入，然后判断控制台是否还有数据输入，如果没有数据输入就退出，然后获取客户端的请求。

/直接返回客户端的请求
                    String response = process(request);
                    //将输出流封装成打印流
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(response);
                    printWriter.flush();
                    System.out.printf("[%s:%d] req: %s;resp: %s\n",clientSocket.getInetAddress().toString(), clientSocket.getPort(),
                            request, response);

![在这里插入图片描述][8861e6d4f7f04dbcbc8851d19ac58bb2.png]

public class EchoServer {
        
        private ServerSocket serverSocket = null;
    
        public EchoServer(int port) throws IOException {
        
            serverSocket = new ServerSocket(port);
        }
    
        public void start() throws IOException {
        
            System.out.println("服务器启动!");
            while (true) {
        
                Socket clientSocket = serverSocket.accept();
                processCoonection(clientSocket);
            }
        }
    
        private void processCoonection(Socket clientSocket) {
        
            System.out.printf("[%s:%d] 客户端上线\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
            try(InputStream inputStream = clientSocket.getInputStream();
                OutputStream outputStream = clientSocket.getOutputStream()) {
        
                while (true) {
        
                    Scanner scanner = new Scanner(inputStream);
                    if(!scanner.hasNext()) {
        
                        //数据已经读完了
                        System.out.printf("[%s:%d] 客户端下线\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                        break;
                    }
                    String request = scanner.next();
                    //直接返回客户端的请求
                    String response = process(request);
                    //将输出流封装成打印流
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(response);
                    printWriter.flush();
                    System.out.printf("[%s:%d] req: %s;resp: %s\n",clientSocket.getInetAddress().toString(), clientSocket.getPort(),
                            request, response);
                }
            }catch (IOException e) {
        
                e.printStackTrace();
            }finally {
        
                try{
        
                    clientSocket.close();
                }catch (IOException e) {
        
                    e.printStackTrace();
                }
            }
        }
    
        public String process(String request) {
        
            return request;
        }
    }

我们现在实现的这个TCP server有个致命的缺点，一次只能处理一个客户端，等我们写完客户端再来分析。

### 客户端 ###

public class EchoClient {
        
        private Socket socket = null;
        public EchoClient(String serverIp,int serverPort) throws IOException {
        
            //我们TCP的Socket对象能够识别点分十进制的IP
            //我们在创建对象的时候，就会与服务器进行连接
            socket = new Socket(serverIp,serverPort);
        }
    }

我们在new 这个对象的过程，就会触发TCP建立连接的过程，如果我们客户端没有这部分代码，那么服务器就会在accept进行阻塞等待。

public void start() {
        
            System.out.println("客户端启动!");
            Scanner scanner = new Scanner(System.in);
            try(InputStream inputStream = socket.getInputStream();
                OutputStream outputStream = socket.getOutputStream()) {
        
                while (true) {
        
                    System.out.print("> ");
                    String request = scanner.next();
                    if(request.equals("exit")) {
        
                        System.out.println("客户端退出!");
                        break;
                    }
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.flush();
                    Scanner respScanner = new Scanner(inputStream);
                    String response = respScanner.next();
                    System.out.println(response);
                }
            }catch (IOException e) {
        
                e.printStackTrace();
            }
        }

我们客户端的收发数据与服务器大差不差，这里就不在一一解释了。  
![在这里插入图片描述][a42adab4f0c54453a4bd6840dc275071.png]  
![在这里插入图片描述][ad9690d6f63541f294097e9b6eac79bb.png]  
分别启动客户端服务器程序。

![在这里插入图片描述][4f6d2491d9dd415dba00cc41be8fd22d.png]  
![在这里插入图片描述][428dc2fe7dff41f1ae2b4ec26795e7d2.png]  
可以成功的收发数据，但是我们当前代码有一个很严重的问题，服务器同一时刻只能处理一个连接，这样是很鸡肋的，我们对服务器进行更新。

### 并发服务器 ###

我们看观察一下我们服务器的代码。  
![在这里插入图片描述][cf8ad3beb6154cb3944eabceb463b7e7.png]  
当我们客户端连接上这个服务器的时候，就执行到processConnection方法的while循环中，只要该方法不结束，我们的accpet就无法获取到第二个客户端socket对象。  
那么我们如何解决这个问题呢?  
使用多线程，我们的主线程专门负责进行accept，每收到一个连接，创建新线程，由新线程来负责处理这个新的客户端。

public void start() throws IOException {
        
            System.out.println("服务器启动!");
            while (true) {
        
                Socket clientSocket = serverSocket.accept();
                Thread t = new Thread(() -> {
        
                    processCoonection(clientSocket);
                });
                t.start();
            }
        }

我们可以使用多线程来解决这个问题，但是现在每获取到一个连接就会创建一个线程，如果同一时刻连接过多，我们创建了大量线程，资源全部耗费在了线程切换上面了，我们可以使用线程池来提升效率。

public void start() throws IOException {
        
            System.out.println("服务器启动!");
            ExecutorService threadPool = Executors.newCachedThreadPool();
            while (true) {
        
                Socket clientSocket = serverSocket.accept();
                threadPool.submit(() -> {
        
                    processCoonection(clientSocket);
                });
            }
        }

尽管我们使用了线程池了，但还是不够，如果我们的客户端非常多，而且都迟迟不断开，就会导致我们会有很多线程，对于我们来说是一个很大的负担。  
能否有办法解决单机支持更大量客户端的问题呢？也是经典的C10M(单机处理1KW个客户端)问题  
这里并不是说单机真正能处理1KW个客户端，只是表达说客户端的量非常大，针对我们上述多线程的版本，我们的机器是承受不了这么多线程的开销的，那么是否有办法一个线程处理很多客户端连接呢? 这就是IO多路复用，IO多路转接技术  
给线程安排一个集合，这个集合放了一堆连接，我们线程负责监听集合，那个连接有数据来了，就处理那个连接。虽然我们的连接有很多，但是我们这里的连接并不是严格意义上的同时，也是有先后的，我们的操作系统里，提供了一些API，比如select，poll，epoll，我们的java里，也提供了一组NIO这样的类，封装了上述技术。

### UDP与TCP ###

我们学习了TCP与UDP的网络编程后，来进行一个对比。  
TCP：  
![在这里插入图片描述][54efe5ec630a4ddc9b9846e70f0ee1fb.png]  
UDP：  
![在这里插入图片描述][ecf8a0589c74433bb93de0f7cc5c7197.png]

[a70b7959025f49f6b318dae821551d2f.gif_pic_center]: https://img-blog.csdnimg.cn/a70b7959025f49f6b318dae821551d2f.gif#pic_center
[IO]: https://blog.csdn.net/buhuisuanfa/article/details/128649463?spm=1001.2014.3001.5501
[8861e6d4f7f04dbcbc8851d19ac58bb2.png]: https://img-blog.csdnimg.cn/8861e6d4f7f04dbcbc8851d19ac58bb2.png
[a42adab4f0c54453a4bd6840dc275071.png]: https://img-blog.csdnimg.cn/a42adab4f0c54453a4bd6840dc275071.png
[ad9690d6f63541f294097e9b6eac79bb.png]: https://img-blog.csdnimg.cn/ad9690d6f63541f294097e9b6eac79bb.png
[4f6d2491d9dd415dba00cc41be8fd22d.png]: https://img-blog.csdnimg.cn/4f6d2491d9dd415dba00cc41be8fd22d.png
[428dc2fe7dff41f1ae2b4ec26795e7d2.png]: https://img-blog.csdnimg.cn/428dc2fe7dff41f1ae2b4ec26795e7d2.png
[cf8ad3beb6154cb3944eabceb463b7e7.png]: https://img-blog.csdnimg.cn/cf8ad3beb6154cb3944eabceb463b7e7.png
[54efe5ec630a4ddc9b9846e70f0ee1fb.png]: https://img-blog.csdnimg.cn/54efe5ec630a4ddc9b9846e70f0ee1fb.png
[ecf8a0589c74433bb93de0f7cc5c7197.png]: https://img-blog.csdnimg.cn/ecf8a0589c74433bb93de0f7cc5c7197.png