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

Python资料网推荐【JavaEE初阶】网络编程TCP协议实现回显服务器以及如何处理多个客户端的响应这篇文章给大家，欢迎收藏Python资料网享受知识的乐趣

前言

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

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

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

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

 

目录

📚️1.TCP相关API

📚️2.回显服务器

2.1概念

2.2服务器的实现

1.初始化Socket类对象

2.启动连接服务器

 3.读取连接的阻塞

4.数据的响应的返回

5.缓冲区的刷新

2.3客户端的实现

1.初始化Socket类对象

2.启动客户端并阻塞

3.发送请求和接收响应

4.文件流close的操作

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

3.1启动多个服务器

3.2处理多客户端请求

1.问题现象

2.问题分析

3.问题解决

4.方法扩展

📚️4.总结

 

📚️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实现回显服务器的操作过程中，服务器的操作，客户端的操作；以及如何处理多个客户端的同时响应，并进行了问题的多方解决~~~

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

---

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

                             😊😊  期待你的关注~~~

版权声明：本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！