【JavaEE初阶】网络编程TCP协议实现回显服务器以及如何处理多个客户端的响应

前言

🌟🌟本期讲解关于TCP/UDP协议的原理理解~~~

🌈感兴趣的小伙伴看一看小编主页：****GGBondlctrl-CSDN博客

**🔥 你的点赞就是小编不断更新的最大动力 **

🎆那么废话不多说直接开整吧~~

📚️1.TCP相关API

和前一期的UDP基本是大差不差的，但是这里提供的方法来模拟对于网卡的操作是有一定的区别的，所示API如下：
ServerSocket是Socket类对应到网卡给服务器使用的类Socket对应到网卡，是给服务器或者客户端来进行使用的
而我们知道在UDP的使用中有DatagramPacket是用于在传输过程中的数据传送的单位，即“面向数据包”，但是这里是没有具体特有的数据传送的类的

注意：由于TCP是一个面向字节流的协议，所以使用的仍然是文件IO部分的操作字节流；
inputstream读数据（字节为单位）outputstream写数据（字节为单位）
所以有了这些铺垫我们就可以使用TCP来实现一个回显服务器了；

📚️2.回显服务器

2.1概念

回显服务器：所谓的回显服务器就是当客户端发送一个请求之后，服务器就直接返回这个响应，在对于请求的解析和操作中是没有任何的逻辑的；（总之就是用户输入什么就得到什么~~）

2.2服务器的实现

1.初始化Socket类对象

这里和UDP的初始化几乎是一样的，即如下代码所示：

public class TcpEchoServer {
    private ServerSocket serverSocket = null;

    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);  //操作模拟网卡的端口号
    }

这里就是通过erverSocket类来实现一个对象，达到模拟控制网卡的操作，用于数据的传输，其中这里的port就是一个服务器的端口号；

2.启动连接服务器

在上述的初始化过后，我们就可直接启动服务器了，代码所示：

 public void start() throws IOException {
        System.out.println("服务器启动了");
        //进入循环
        while (true) {
            //建立连接
            Socket Clientsocket = serverSocket.accept();
            processClient(Clientsocket);
        }
    }

解释：当我们启动服务器之后，这里就要进行服务器与客户端的连接，为啥要进行连接呢，主要是因为TCP是一个有连接的协议，这就类似于打电话一样，两边要接听后才能够进行通信，然后将数据传给另一个方法操作；

如下图所示：

此时应用程序中调用对应的API来尝试和服务器建立连接，然后内核态就会尝试发起建立连接的流程，然后服务器这边的内核态就会配合进行连接；

注意：内核发起连接是用户程序来进行操作的，所以这里就要调用accept来进行连接；

3.读取连接的阻塞

当客户端和服务器建立连接，传入数据进行操作时，此时服务器就会进入阻塞状态，那么就有一下代码来进行实现：

private void processClient(Socket Clientsocket) { //处理连接来的数据
        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;
                }

解释：

由于TCP的面向字节流，所以我们可以通过inputstream来实现这里的操作，此时将这里的操作写到try里是为了自动执行close的关闭文件流的操作；

通过scanner来读取字节数据，然后通过scanner.hashnext来实现没有输入时就进行跳出循环操作，这里就是客户端下线了；

4.数据的响应的返回

在这里通过字节数据的请求操作实现对于客户端的响应，代码如下：

String request = scanner.next();
                //进行响应操作
                String response = process(request);
                //将响应传给客户端
                //给outputstream进行外包装
                PrintWriter printWriter = new PrintWriter(OutputStream);
                printWriter.println(response);

解释：这里的process操作就是直接返回需求作为响应，然后这里小编就通过printwriter来包装了outputstream这个写数据的操作，就是替代了这个代码：

OutputStream.write(response.getBytes(),0,response.getBytes().length)

这里两个的区别：
OutputStream ：你需要将字符串手动转换为字节数组发送，例如；

String response = "收到你的消息";
byte[] responseBytes = response.getBytes();
outputStream.write(responseBytes);

PrintWriter ：它提供了更方便的 print 和 println 方法，可以直接发送字符串；

PrintWriter 会自动处理字符编码等细节，并且在构造函数的第二个参数传入 true 时能够自动刷新缓冲区，确保消息及时发送。这使得代码更加简洁易读，减少了因字节处理而可能产生的错误。

5.缓冲区的刷新

这里是printwriter提供的缓冲区在这里面进行了操作，解决代码如下：

 printWriter.flush();//刷新缓冲区，让数据发送出去

解释：这就是刷新缓冲区的意思，为啥要刷新缓冲区呢？？？

注意：这里的IO操作是一个比较低效的操作，所以就会尽量减少对于文件IO的操作，所以要操作网卡的数据存放到内存缓冲区里，当积攒到一定的量后再发给下一层协议

所以当数据太少的时候，就会存在缓冲区里，并没有发送出去，所以这里要进行刷新的操作；

2.3客户端的实现

1.初始化Socket类对象

和上面的服务器初始化是一致的，只不过使用的类不一样，代码如下：

public class TcpEchoClient {
    private Socket socket=null;
    public TcpEchoClient(String ServerIP, int ServerPort) throws IOException {
        //由于tcp是有连接的，所以会自动保存这里的ip和端口号
        socket=new Socket(ServerIP,ServerPort);
    }

解释：这里通过socket对象，实现对于网卡的模拟操作，在构造函数的时候定义服务器的IP地址以及服务器的端口号；

2.启动客户端并阻塞

这里在启动客户端后直接进入循环，进行不断的从服务器读取响应，代码如下：

public void start(){
        System.out.println("客户端启动了");
        try (InputStream inputStream=socket.getInputStream();
             OutputStream outputStream= socket.getOutputStream()){
            Scanner scannerConsole=new Scanner(System.in);
            Scanner scannernetwork=new Scanner(inputStream);
            PrintWriter writer=new PrintWriter(outputStream);
            while (true){
                System.out.println("->");
                if(!scannerConsole.hasNext()){
                    break;
                }

解释:这里还是通过inputstream和outputstream来进行操作，这里的两个scanner分别的用途如下所示;

第一个scanner是用于客户在控制台上进行字符串的输入；

第二个scanner是用于字节数据的读取，就是从服务器响应过后的数据接收；

第三个printwriter用于写数据给服务器，这里就是发送请求的意思

之后进入用户的输入阻塞，当不输入时，就直接跳出循环，客户端下线；

3.发送请求和接收响应

当执行上述步骤之后，我们就要执行对于服务器数据的发送请求和接收响应的操作了，代码如下：

 String request=scannerConsole.next();
                //发送数据用到写的操作
                writer.println(request);
                writer.flush();
                //接收数据
                String response=scannernetwork.next();

                System.out.println(response);

解释：这里将用户输入的请求通过writer写给服务器，并刷新了缓存，保证字节数组能够发送出去，最后通过scannernetwork来接收数据，并转化为字符串类型数据，最后在打印即可；

4.文件流close的操作

1.serversocket

解释：由于整个程序中只有一个serversocket对象，并且这个对象的生命周期很长，随着服务器的退出自动销毁，所以不需要进行close操作；

2.clientSocket

解释：由于clientsocket是每个客户端都有一个，由于连接的客户端越来越多，不释放socket就会导致将文件描述附表占满，所以这里要进行close的操作；

代码如下：

finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

这里就添加在服务器try-catch的后面即可~~~

📚️3.处理多个客户端同时响应

3.1启动多个服务器

当我们执行代码，启动多个服务器的时候会发现此时idea会终止这个原来的进程，然后执行新的代码，即新的进程，那么解决办法如下所示：

点击后进入如下的画面，然后进入一个新的界面点击如下：

然后这里代表的就是允许多个实例的运行，那么就可以重复执行代码，实现多个服务器同时运行的实现；

3.2处理多客户端请求

1.问题现象

此时当我们对第一个客户端进行输入的时候，发现此时服务器对于客户端是有响应的，如下图所示：

此时是有客户端输入后，会得到响应的，但是此时我们对于第二个客户端进行打印的时候，这里是没有出现响应的：

此时我们可以看见服务器对于两个客户端的上线状态也是不一样的，如下图所示：

很明显这里就是只上线了一个客户端，那么这就是第二个客户端得不到响应的原因；

2.问题分析

流程：首先这里的服务器主循环是通过clientsocket来进行数据连接，然后再进入数据操作的循环，即有以下几个步骤：

1.读取请求并且进行解析；

2.对于解析做出响应；

3.将响应传回给客户端；

注意：这是一个死循环，只要这个循环不结束（即连接这个服务器的第一个客户端不结束）那么就会导致服务器一直在这个循环等待客户端1号的请求，并做出响应；

虽然这里第二个客户端实现了内核上运用accept与服务器建立了连接，但是无法将连接拿到程序里进行处理，这就是整个多客户端 请求不成功的主要原因；

3.问题解决

使用多线程

对这个processClient(Clientsocket)来进行多个线程处理多个客户端的请求与响应，具体代码如下所示：

while (true) {
            //建立连接
            Socket Clientsocket = serverSocket.accept();
            Thread t=new Thread(()->{
                processClient(Clientsocket);
            });
            t.start();
        }

解释：那么此时当申请一个客户端的时候，那么就会创建一个线程来对这个客户端进行服务，此时就解决了多客户端请求的问题；

使用线程池

由于上述的操作，会导致一个客户端执行，就会创建一个线程，一个客户端执行完了，就会销毁一个线程，那么此时就会造成线程频繁创建销毁的开销增大；

那么这里就引入了线程池，这个概念，具体代码如下：

 while (true) {
            //建立连接
            Socket Clientsocket = serverSocket.accept();
           
            ExecutorService pool= Executors.newCachedThreadPool();
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    processClient(Clientsocket);
                }
            });
        }

解释：那么此时当创建好线程后，客户端执行，那么就会从线程池中拿一个线程进行服务客户端，当客户端执行结束后，将线程入到线程池，就不会销毁，节省了线程创建的开销；

4.方法扩展

引入协程

这里的协程就是轻量级线程，用户态可以手动的调度这个协程，并发的执行多个客户端；那么此时由于协程的创建和销毁是用户态进行手动控制的，所以就省去了系统内核的调度开销；

IO多路复用

IO多路复用：这里就是一个系统内核级别的机制，主要的内容机制就是一个线程同时负责多个socket的处理；

本质：即每个socket需要操作的数据不是同一时间处理的；

举例：假如我去买街上买吃的，我可以点好餐后，等待后，拿到餐了，那么去买另一个东西；那么我也可以等买完餐后直接去买另一个东西，此时在等这两个东西完成后，再去拿；这里的本质就是每个东西的不是同一个时间执行的；

📚️4.总结

💬💬本期小编主要讲解了关于TCP实现回显服务器的操作过程中，服务器的操作，客户端的操作；以及如何处理多个客户端的同时响应，并进行了问题的多方解决~~~

🌅🌅🌅~~~~最后希望与诸君共勉，共同进步！！！

💪💪💪以上就是本期内容了， 感兴趣的话，就关注小编吧。

** 😊😊 期待你的关注~~~**