回显服务器（基于TCP）

快来打我* 2024-04-25 08:44 1阅读 0赞

**目录**

API学习

ServerSocket

Socket

服务端

思路分析

具体实现

客户端

思路分析

具体实现

运行测试

问题分析

修改优化

完整代码

--------------------

在学习了基于UDP实现的回显服务器后，我们学习基于TCP实现的回显服务器

## API学习 ##

### ServerSocket ###

ServerSocket是**创建TCP服务端Socket**的API

**构造方法：**

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ServerSocket(int port)</td> 
   <td>创建一个服务端流套接字Socket，并绑定到指定端口</td> 
  </tr> 
 </tbody> 
</table>

**常用方法：**

<table style="width:500px;"> 
 <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**，**或服务端中接收到客户端连接（accept方法）的请求后，返回的服务端Socket**

无论是客户端还是服务端Socket，都是双方建立连接后，保存对端信息以及用来与对方收发数据的。

**构造方法：**

<table style="width:500px;"> 
 <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 style="width:500px;"> 
 <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>

## 服务端 ##

### 思路分析 ###

对于服务端，要实现的内容有：

> **1. 与客户端建立连接**
> 
> **2. 接收客户端发送的请求、读取解析请求**
> 
> **3. 根据请求计算数据响应**
> 
> **4. 将响应返回给客户端**

由于服务器要等到客户端发送请求时才能进行接收、解析、计算响应等操作，而服务器不知道客户端什么时候发送请求，因此服务器需要一直“待命”，等待客户端发送请求

### 具体实现 ###

**1.首先我们需要创建一个ServerSocket对象，并通过构造方法来指定服务器要绑定的端口号**

import java.io.IOException;
    import java.net.ServerSocket;
    
    public class TcpEchoServer {
        private ServerSocket socket = null;
        public TcpEchoServer(int port) throws IOException {
            socket = new ServerSocket(port);
        }
    }

**2.接下来，我们实现客户端与服务端连接的建立**

TCP是**有连接**的，因此，在进行通信之前，客户端和服务器之间需要建立连接（就像打电话一样，需要一端拨号，另一端接听后，双方才能进行通话）

![010f4ee972574c478532d7a2941bd8af.png][]

除了内核建立连接外，还需要服务端进行“接听”（accept操作），才能进行通信

public void start() throws IOException {
            System.out.println("启动服务器");
            while (true){
                //通过accept方法来“接听”
                Socket clientSocket = socket.accept();
            }
        }

**3.** **然后通过实现processConnection方法来处理每一次连接****建立后的通信（客户端与服务器之间的多次请求响应交互）**

此时的实现过程与 基于UDP实现的回显服务器类似，循环读取请求、接收请求并解析、根据请求计算响应最后将响应返回给客户端

**需要注意的是，TCP是面向字节流的，传输的基本单位是字节**

//处理连接建立后客户端与服务器之间的多次请求响应
        private void processConnection(Socket clientSocket) throws IOException {
            System.out.printf("[%s:%d] 客户端上线\n",clientSocket.getInetAddress(),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(),clientSocket.getPort());
                        break;
                    }
                    //读取请求并解析
                    String request = scanner.next();
                    //根据请求计算响应
                    String response = process(request);
                    //将响应返回给客户端
                    //由于直接通过outputStream进行写入不方便在响应末尾添加\n
                    //因此可以使用PrintWriter进行写入(使用其中的println方法)
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(response);
                    //不要忘记刷新操作
                    printWriter.flush();
                    //打印日志，观察程序执行效果
                    System.out.printf("[%s:%d] req: %s, resp: %s\n",clientSocket.getInetAddress(),clientSocket.getPort(),
                            request, response);
                }
    
            }catch (IOException e){
                throw new RuntimeException(e);
            }finally {
                clientSocket.close();
            }
        }
        
        //根据请求计算响应
        public String process(String request) {
            return request;
        }

## 客户端 ##

### 思路分析 ###

对于客户端需要实现的内容有：

> **1. 从控制台读取用户输入的内容**
> 
> **2. 将内容构造成TCP请求，并发送给服务器**
> 
> **3. 等待服务器响应，当接收到服务器响应时，解析响应内容**
> 
> **4. 显示响应内容**

### 具体实现 ###

**1.首先我们创建一个Socket对象，并在构造方法中传入服务器的ip和端口号**

import java.io.IOException;
    import java.net.Socket;
    
    public class TcpEchoClient {
        private Socket socket = null;
        public TcpEchoClient(String serverIp, int serverPort) throws IOException {
            socket = new Socket(serverIp, serverPort);
        }
    }

**2. 接下来我们实现客户端的启动（循环读取请求、发送请求、读取响应最后打印响应内容）**

public void start(){
            System.out.println("启动客户端");
            try (InputStream inputStream = socket.getInputStream();
                 OutputStream outputStream = socket.getOutputStream()){
                Scanner scanner = new Scanner(System.in);//从控制台读取要发送的请求数据
                Scanner scannerNetwork = new Scanner(inputStream);//从服务器读取响应
                PrintWriter writer = new PrintWriter(outputStream);//通过PrintWriter进行写入操作
                while (true){
                    //从控制台读取请求数据
                    System.out.print("请输入：");
                    if(!scanner.hasNext()){//读取完毕，退出循环
                        break;
                    }
                    String request = scanner.next();//读取请求
                    //将请求发送给服务器
                    writer.println(request);//使用println方法来发送数据，使请求末尾带有\n
                    writer.flush();//刷新缓冲区，使数据及时发送出去
                    //从服务器读取响应
                    String response = scannerNetwork.next();
                    //显示响应内容
                    System.out.println(response);
                    
                    
                }
            }catch (IOException e){
                throw new RuntimeException(e);
            }
        }

## 运行测试 ##

在编写完代码后，我们同时运行服务器和客户端，并输入请求观察代码是否存在问题：

**启动服务器：**

public static void main(String[] args) throws IOException {
            TcpEchoServer server = new TcpEchoServer(9019);
            server.start();
        }

**启动客户端：**

public static void main(String[] args) throws IOException {
            TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9019);
            client.start();
        }

**运行测试结果：**

**服务器：**

![758834fb4bbd4dcaa66608e53fc88c99.png][]

**客户端：**

![fe01af7a25ab49109412ac4f04285ff4.png][]

**再运行一个客户端：**

![19100147bcaf4a6aaed3a3f40a13d384.png][]

![f30b2f92b44f4ab996bb8370a7fc5c2c.png][]

![58501229940a4b9e98642be65ce5c66e.png][]

![18e9da3db16546dbb3dc65a023994722.png][]

**运行结果：**

![bfe0ad3cc14d4795907d58c24457da7c.png][]

此时第二个客户端无响应，当关闭第一个客户端后，此时第二个客户端才能正常工作

![656a9494cefa4ad9b93649c64379ebfd.png][]

### 问题分析 ###

> **为什么会出现这种情况呢？**

通过观察服务器代码，我们可以发现：当第一个客户端与服务器建立连接后，服务器就进入processConnection，此时会在scanner.hasNext 阻塞，等待客户端的请求，接收请求后，解析计算响应并返回，然后再次等待请求....，直到该客户端退出后，才能结束processConnection方法，再次进行“接听”

![58e3f4b57aed420d825dab17d5400049.png][]

因此，当有新的客户端与服务器建立连接时，虽然新的客户端与服务器在内核层面建立了TCP连接，但服务端未“接听”，因此连接未成功建立，也就无法进行交互。第二个客户端发送的请求存储在服务器的接收缓冲区中，当第一个客户端退出后，服务器就会立即处理第二个客户端之前发送的请求

**那应该如何修改代码，使得服务器能够同时与多个客户端建立连接呢？**

## 修改优化 ##

此时使用单线程已经无法满足我们的需求，因此我们考虑使用**多线程**，主线程负责执行accecpt，**每当有一个客户端进行连接，就分配一个新的线程，由这个新线程为客户端提供服务**

public void start() throws IOException {
            System.out.println("启动服务器");
            while (true){
                //通过accept方法来“接听”
                Socket clientSocket = socket.accept();
                Thread woker = new Thread(()->{
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                });
                woker.start();
            }
        }

此时服务器就能够处理多个客户端的请求了

![6bea217c7d5a4094878af1e07c11881a.png][]

然而，当客户端比较多时，服务器就会频繁地创建和销毁线程，此时，我们可以考虑使用**线程池**

### 完整代码 ###

**服务端代码：**

import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.Scanner;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class TcpEchoServer {
        private ServerSocket socket = null;
        public TcpEchoServer(int port) throws IOException {
            socket = new ServerSocket(port);
        }
        public void start() throws IOException {
            System.out.println("启动服务器");
            ExecutorService pool = Executors.newCachedThreadPool();
            while (true){
                //通过accept方法来“接听”
                Socket clientSocket = socket.accept();
               /* Thread woker = new Thread(()->{
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                });
                woker.start();*/
                pool.submit(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            processConnection(clientSocket);
                        } catch (IOException e) {
                            throw new RuntimeException(e);
                        }
                    }
                });
    
            }
        }
        //处理连接建立后客户端与服务器之间的多次请求响应
        private void processConnection(Socket clientSocket) throws IOException {
            System.out.printf("[%s:%d] 客户端上线\n",clientSocket.getInetAddress(),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(),clientSocket.getPort());
                        break;
                    }
                    //读取请求并解析
                    String request = scanner.next();
                    //根据请求计算响应
                    String response = process(request);
                    //将响应返回给客户端
                    //由于直接通过outputStream进行写入不方便在响应末尾添加\n
                    //因此可以使用PrintWriter进行写入(使用其中的println方法)
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(response);
                    //不要忘记刷新操作
                    printWriter.flush();
                    //打印日志，观察程序执行效果
                    System.out.printf("[%s:%d] req: %s, resp: %s\n",clientSocket.getInetAddress(),clientSocket.getPort(),
                            request, response);
                }
    
            }catch (IOException e){
                throw new RuntimeException(e);
            }finally {
                clientSocket.close();
            }
        }
    
        //根据请求计算响应
        public String process(String request) {
            return request;
        }
    
        public static void main(String[] args) throws IOException {
            TcpEchoServer server = new TcpEchoServer(9019);
            server.start();
        }
    }

**客户端代码：**

import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.net.Socket;
    import java.util.Scanner;
    
    public class TcpEchoClient {
        private Socket socket = null;
        public TcpEchoClient(String serverIp, int serverPort) throws IOException {
            socket = new Socket(serverIp, serverPort);
        }
        public void start(){
            System.out.println("启动客户端");
            try (InputStream inputStream = socket.getInputStream();
                 OutputStream outputStream = socket.getOutputStream()){
                Scanner scanner = new Scanner(System.in);//从控制台读取要发送的请求数据
                Scanner scannerNetwork = new Scanner(inputStream);//从服务器读取响应
                PrintWriter writer = new PrintWriter(outputStream);//通过PrintWriter进行写入操作
                while (true){
                    //从控制台读取请求数据
                    System.out.print("请输入：");
                    if(!scanner.hasNext()){//读取完毕，退出循环
                        break;
                    }
                    String request = scanner.next();//读取请求
                    //将请求发送给服务器
                    writer.println(request);//使用println方法来发送数据，使请求末尾带有\n
                    writer.flush();//刷新缓冲区，使数据及时发送出去
                    //从服务器读取响应
                    String response = scannerNetwork.next();
                    //显示响应内容
                    System.out.println(response);
    
    
                }
            }catch (IOException e){
                throw new RuntimeException(e);
            }
        }
    
        public static void main(String[] args) throws IOException {
            TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9019);
            client.start();
        }
    }

[010f4ee972574c478532d7a2941bd8af.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/bc2a06da3b7b4d2aa1ef9773ccdb072f.png
[758834fb4bbd4dcaa66608e53fc88c99.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/03aa66338a28401b8245250b5e012e48.png
[fe01af7a25ab49109412ac4f04285ff4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/78085ea058b548c4a040fde6707d9969.png
[19100147bcaf4a6aaed3a3f40a13d384.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/db58310d1b1e48f9a06d52214cc87929.png
[f30b2f92b44f4ab996bb8370a7fc5c2c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/e717abbdfde8494fbdb293311dd2c002.png
[58501229940a4b9e98642be65ce5c66e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/cc4fe84cf3f245fcaac1e322fccde127.png
[18e9da3db16546dbb3dc65a023994722.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/bffbc71853924ca082f2ae7bcfd673ac.png
[bfe0ad3cc14d4795907d58c24457da7c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/2d769ab5e047481bad05e090b540609c.png
[656a9494cefa4ad9b93649c64379ebfd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/f133598247c54607be7b2f6d50a445ef.png
[58e3f4b57aed420d825dab17d5400049.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/1410a43b261447b6bf20dbe638341bb7.png
[6bea217c7d5a4094878af1e07c11881a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/3d15f452eff54145890f04d3dc2b5e85.png