Java TCP长连接详解:实现稳定、高效的网络通信

这篇具有很好参考价值的文章主要介绍了Java TCP长连接详解:实现稳定、高效的网络通信。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

在现代互联网应用中,稳定而高效的网络通信是至关重要的。而TCP长连接作为一种常见的通信机制,允许客户端和服务器之间保持长时间的连接,有效地传输数据。本文将详细介绍Java中TCP长连接的概念、优点、适用场景,并结合实际案例进行分析。

概念:

TCP长连接是一种建立在TCP/IP协议之上的网络通信方式。传统的TCP连接是短连接,即在通信完成后立即断开连接,而TCP长连接则是在通信完成后保持连接状态,使得客户端和服务器之间可以保持持久的通信。

在TCP长连接中,客户端和服务器之间建立连接的过程与短连接相同,包括三次握手、建立连接等步骤。但是在通信完成后,TCP长连接并不主动关闭连接,而是保持连接状态,直到一方主动关闭连接或者连接出现异常断开。

TCP长连接的优点之一是减少连接和断开的开销。在短连接中,每次通信都需要重新建立连接,包括握手、认证等操作,这些额外的开销会增加网络通信的延迟和资源消耗。而TCP长连接可以避免这一过程,减少了连接和断开的开销,提高了通信的效率。

另一个优点是实时性和低延迟。通过保持连接,实时数据可以更快地传输到目标端,降低了响应时间和延迟,提供了更好的用户体验。在实时数据传输场景中,如在线游戏或即时通讯应用,TCP长连接可以快速传递实时的位置信息、消息等,实现实时的交互。

TCP长连接还可以节省带宽和资源。长连接可以复用已经建立的连接,避免了每次连接时的握手和认证过程,减少了带宽和服务器资源的消耗。特别是在高频信息交互场景中,如股票行情或物联网应用,TCP长连接的节省资源的特点更为明显。

另外,TCP长连接还具有更好的稳定性和可靠性。长连接保持持久的通信状态,当网络出现中断或异常时,连接可以自动恢复,确保数据的可靠传输。对于需要长时间保持通信的应用,如远程监控或大规模数据同步,TCP长连接能够提供更好的稳定性。

尽管TCP长连接有很多优点,但并不是所有场景都适合使用。对于瞬时性的数据传输,如HTTP请求,短连接可能更为适合。而对于需要实时性、稳定性和节省资源的场景,如实时数据传输、高频信息交互等,TCP长连接是一种值得考虑的通信方式。

优点:

  1. 减少连接和断开的开销:传统的短连接需要反复建立和释放连接,而TCP长连接避免了这一过程,减少了网络连接的开销,提高了通信效率。
  2. 实时性和低延迟:通过保持连接,实时数据可以更快地传输到目标端,降低了响应时间和延迟,提供更好的用户体验。
  3. 节省带宽和资源:长连接可以复用已经建立的连接,减少了每次连接时的握手和认证过程,节省了带宽和服务器资源。
  4. 更好的稳定性和可靠性:长连接可以保持持久的通信状态,当网络出现中断或异常时,连接可以自动恢复,确保数据的可靠传输。

场景:

  1. 实时数据传输:TCP长连接常用于实时数据传输场景,如在线游戏、即时通讯等,保持连接可以快速传递实时数据,提供流畅的用户体验。比如,在一个在线游戏中,玩家之间可以通过长连接传输位置信息、动作指令等,实现实时游戏世界的同步。
  2. 数据同步和推送:长连接可以用于数据同步和推送场景,如消息推送、设备状态同步等,确保数据的及时更新和同步。比如,一个即时通讯应用可以通过长连接实时推送新消息,确保用户能够及时收到新的聊天信息。
  3. 高频信息交互:长连接适用于高频信息交互场景,如股票行情、物联网等,减少了连接建立和断开的开销,提高了通信效率。例如,在一个股票交易系统中,客户端可以通过长连接获取股票行情信息,实时了解市场动态。

场景1:实时消息推送

在实时消息推送场景中,服务器需要向客户端实时地发送消息,例如聊天消息、系统通知等。客户端需要接收并处理这些消息,以实现实时通信的效果。

服务器端代码示例(使用Java的WebSocket):

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@ServerEndpoint("/chat")
public class ChatServer {
    private static List<Session> clients = new ArrayList<>();

    @OnOpen
    public void onOpen(Session session) {
        clients.add(session);
        System.out.println("有新的客户端连接,当前在线人数:" + clients.size());
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("接收到客户端消息:" + message);
        broadcast(message);
    }

    @OnClose
    public void onClose(Session session) {
        clients.remove(session);
        System.out.println("有客户端断开连接,当前在线人数:" + clients.size());
    }

    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    private void broadcast(String message) {
        for (Session client : clients) {
            try {
                client.getBasicRemote().sendText(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端代码示例(使用Java的WebSocket):

import javax.websocket.*;
import java.io.IOException;
import java.net.URI;
import java.util.Scanner;

@ClientEndpoint
public class ChatClient {
    private static final String SERVER_URI = "ws://localhost:8080/chat";

    @OnOpen
    public void onOpen(Session session) {
        System.out.println("已连接到服务器");
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("接收到服务器消息:" + message);
    }

    @OnClose
    public void onClose(Session session, CloseReason reason) {
        System.out.println("已断开与服务器的连接:" + reason.getReasonPhrase());
    }

    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    public static void main(String[] args) {
        WebSocketContainer container = ContainerProvider.getWebSocketContainer();
        try {
            Session session = container.connectToServer(ChatClient.class, URI.create(SERVER_URI));
            System.out.println("连接已建立");

            Scanner scanner = new Scanner(System.in);
            while (true) {
                String message = scanner.nextLine();
                session.getBasicRemote().sendText(message);
            }
        } catch (DeploymentException | IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码使用Java的WebSocket API实现了一个简单的实时聊天室。服务器端使用@ServerEndpoint注解标记一个WebSocket端点,并实现了相应的事件处理方法。客户端使用@ClientEndpoint注解标记一个WebSocket客户端,并实现了相应的事件处理方法。

服务器端使用broadcast方法将接收到的消息广播给所有连接的客户端。客户端可以通过session.getBasicRemote().sendText(message)方法向服务器发送消息,并通过@OnMessage注解接收服务器发送的消息。

在实际应用中,可以根据需要修改和扩展这些代码,添加认证、消息过滤等功能,以满足实际的业务需求。

场景2:在线多人游戏

在在线多人游戏中,多个玩家需要通过服务器进行实时的游戏交互,包括角色移动、攻击等操作。服务器需要接收并处理玩家的操作,并将操作结果广播给其他玩家。

服务器端代码示例(使用Java的Socket编程):

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

public class GameServer {
    private static final int PORT = 8888;
    private List<Socket> players;

    public GameServer() {
        players = new ArrayList<>();
    }

    public void start() {
        try {
            ServerSocket serverSocket = new ServerSocket(PORT);
            System.out.println("服务器已启动,等待玩家连接...");

            while (true) {
                Socket playerSocket = serverSocket.accept();
                players.add(playerSocket);
                System.out.println("玩家已连接");

                Thread playerThread = new Thread(new PlayerThread(playerSocket));
                playerThread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private class PlayerThread implements Runnable {
        private Socket playerSocket;

        public PlayerThread(Socket playerSocket) {
            this.playerSocket = playerSocket;
        }

        @Override
        public void run() {
            try {
                InputStream is = playerSocket.getInputStream();
                OutputStream os = playerSocket.getOutputStream();
                byte[] buffer = new byte[1024];
                int length;

                while ((length = is.read(buffer)) != -1) {
                    String message = new String(buffer, 0, length);
                    System.out.println("接收到玩家消息:" + message);

                    // 处理玩家消息
                    // ...

                    // 将消息广播给其他玩家
                    for (Socket otherSocket : players) {
                        if (otherSocket != playerSocket) {
                            os = otherSocket.getOutputStream();
                            os.write(message.getBytes());
                            os.flush();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    playerSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        GameServer gameServer = new GameServer();
        gameServer.start();
    }
}

客户端代码示例(使用Java的Socket编程):

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

public class GameClient {
    private static final String SERVER_IP = "127.0.0.1";
    private static final int SERVER_PORT = 8888;

    public void start() {
        try {
            Socket socket = new Socket(SERVER_IP, SERVER_PORT);
            System.out.println("已连接服务器");

            Thread sendThread = new Thread(new SendThread(socket));
            sendThread.start();

            Thread receiveThread = new Thread(new ReceiveThread(socket));
            receiveThread.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private class SendThread implements Runnable {
        private Socket socket;

        public SendThread(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try {
                OutputStream os = socket.getOutputStream();
                Scanner scanner = new Scanner(System.in);

                while (true) {
                    String message = scanner.nextLine();
                    os.write(message.getBytes());
                    os.flush();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private class ReceiveThread implements Runnable {
        private Socket socket;

        public ReceiveThread(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try {
                InputStream is = socket.getInputStream();
                byte[] buffer = new byte[1024];
                int length;

                while ((length = is.read(buffer)) != -1) {
                    String message = new String(buffer, 0, length);
                    System.out.println("接收到服务器消息:" + message);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        GameClient gameClient = new GameClient();
        gameClient.start();
    }
}

以上是一个简单的在线多人游戏的示例,服务器可以接收玩家的消息,并将消息广播给其他玩家。客户端可以发送消息到服务器,并接收服务器广播的消息。在实际的游戏开发中,还需要更多的逻辑来处理游戏的交互和状态。

案例:

案例1:股票实时价格推送

在股票交易系统中,经常需要实时推送股票的最新价格给客户端。以下是一个简单的实现代码示例:

服务器端:

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

@ServerEndpoint("/stock")
public class StockServer {
    private static List<Session> clients = new ArrayList<>();
    private static Random random = new Random();

    @OnOpen
    public void onOpen(Session session) {
        clients.add(session);
        System.out.println("有新的客户端连接,当前在线人数:" + clients.size());

        // 开始推送股票价格
        new Thread(() -> {
            try {
                while (true) {
                    double price = random.nextDouble() * 100.0;
                    broadcast("股票价格:" + price);
                    Thread.sleep(2000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

    @OnClose
    public void onClose(Session session) {
        clients.remove(session);
        System.out.println("有客户端断开连接,当前在线人数:" + clients.size());
    }

    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    private void broadcast(String message) {
        for (Session client : clients) {
            try {
                client.getBasicRemote().sendText(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端:

import javax.websocket.*;
import java.io.IOException;
import java.net.URI;

@ClientEndpoint
public class StockClient {
    private static final String SERVER_URI = "ws://localhost:8080/stock";

    @OnOpen
    public void onOpen(Session session) {
        System.out.println("已连接到服务器");
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("接收到股票价格:" + message);
    }

    @OnClose
    public void onClose(Session session, CloseReason reason) {
        System.out.println("已断开与服务器的连接:" + reason.getReasonPhrase());
    }

    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    public static void main(String[] args) {
        WebSocketContainer container = ContainerProvider.getWebSocketContainer();
        try {
            Session session = container.connectToServer(StockClient.class, URI.create(SERVER_URI));
            System.out.println("连接已建立");

            // 可以在这里添加其他代码,例如用户认证、接收用户输入等操作

        } catch (DeploymentException | IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码在服务器端模拟生成随机的股票价格,然后将价格推送给所有连接的客户端。客户端收到价格后进行相应的处理。

案例2:实时天气信息推送

在一个天气查询系统中,可以实时推送天气信息给用户。以下是一个简单的实现代码示例:

服务器端:

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

@ServerEndpoint("/weather")
public class WeatherServer {
    private static List<Session> clients = new ArrayList<>();
    private static Random random = new Random();

    @OnOpen
    public void onOpen(Session session) {
        clients.add(session);
        System.out.println("有新的客户端连接,当前在线人数:" + clients.size());

        // 开始推送天气信息
        new Thread(() -> {
            try {
                while (true) {
                    String weather = generateWeather();
                    broadcast("当前天气:" + weather);
                    Thread.sleep(5000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

    @OnClose
    public void onClose(Session session) {
        clients.remove(session);
        System.out.println("有客户端断开连接,当前在线人数:" + clients.size());
    }

    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    private void broadcast(String message) {
        for (Session client : clients) {
            try {
                client.getBasicRemote().sendText(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private String generateWeather() {
        String[] weatherOptions = {"晴天", "多云", "阴天", "小雨", "雷阵雨"};
        int index = random.nextInt(weatherOptions.length);
        return weatherOptions[index];
    }
}

客户端:

import javax.websocket.*;
import java.io.IOException;
import java.net.URI;

@ClientEndpoint
public class WeatherClient {
    private static final String SERVER_URI = "ws://localhost:8080/weather";

    @OnOpen
    public void onOpen(Session session) {
        System.out.println("已连接到服务器");
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("接收到天气信息:" + message);
    }

    @OnClose
    public void onClose(Session session, CloseReason reason) {
        System.out.println("已断开与服务器的连接:" + reason.getReasonPhrase());
    }

    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    public static void main(String[] args) {
        WebSocketContainer container = ContainerProvider.getWebSocketContainer();
        try {
            Session session = container.connectToServer(WeatherClient.class, URI.create(SERVER_URI));
            System.out.println("连接已建立");

            // 可以在这里添加其他代码,例如用户认证、接收用户输入等操作

        } catch (DeploymentException | IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码在服务器端模拟生成随机的天气信息,然后将信息推送给所有连接的客户端。客户端收到天气信息后进行相应的处理。

案例3:实时股票交易信息推送

在股票交易系统中,实时推送股票的交易信息给用户是非常重要的。以下是一个简单的实现代码示例:

服务器端:

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

@ServerEndpoint("/trading")
public class TradingServer {
    private static List<Session> clients = new ArrayList<>();
    private static Random random = new Random();

    @OnOpen
    public void onOpen(Session session) {
        clients.add(session);
        System.out.println("有新的客户端连接,当前在线人数:" + clients.size());

        // 开始推送交易信息
        new Thread(() -> {
            try {
                while (true) {
                    String tradingInfo = generateTradingInfo();
                    broadcast("交易信息:" + tradingInfo);
                    Thread.sleep(3000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

    @OnClose
    public void onClose(Session session) {
        clients.remove(session);
        System.out.println("有客户端断开连接,当前在线人数:" + clients.size());
    }

    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    private void broadcast(String message) {
        for (Session client : clients) {
            try {
                client.getBasicRemote().sendText(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private String generateTradingInfo() {
        String[] stockOptions = {"AAPL", "GOOGL", "AMZN", "FB", "MSFT"};
        int stockIndex = random.nextInt(stockOptions.length);

        double price = random.nextDouble() * 100.0;
        int quantity = random.nextInt(100);

        return stockOptions[stockIndex] + " - 价格:" + price + ",数量:" + quantity;
    }
}

客户端:

import javax.websocket.*;
import java.io.IOException;
import java.net.URI;

@ClientEndpoint
public class TradingClient {
    private static final String SERVER_URI = "ws://localhost:8080/trading";

    @OnOpen
    public void onOpen(Session session) {
        System.out.println("已连接到服务器");
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("接收到交易信息:" + message);
    }

    @OnClose
    public void onClose(Session session, CloseReason reason) {
        System.out.println("已断开与服务器的连接:" + reason.getReasonPhrase());
    }

    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
    }
}

总结:

本文详细介绍了Java中TCP长连接的概念、优点、适用场景,并结合实际案例进行了分析。TCP长连接作为一种稳定且高效的网络通信机制,可以提供实时性、低延迟、节省带宽和资源等优势。在适用的场景下,合理地使用TCP长连接可以有效改善网络通信的质量和效率,提升用户体验。通过给出一个基于Java的即时聊天应用案例,展示了TCP长连接在实时消息传输中的应用。文章来源地址https://www.toymoban.com/news/detail-774119.html

到了这里,关于Java TCP长连接详解:实现稳定、高效的网络通信的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java【网络编程2】使用 TCP 的 Socket API 实现客户端服务器通信(保姆级教学, 附代码)

    📕各位读者好, 我是小陈, 这是我的个人主页 📗小陈还在持续努力学习编程, 努力通过博客输出所学知识 📘如果本篇对你有帮助, 烦请点赞关注支持一波, 感激不尽 📙 希望我的专栏能够帮助到你: JavaSE基础: 基础语法, 类和对象, 封装继承多态, 接口, 综合小练习图书管理系统

    2024年02月05日
    浏览(62)
  • 【Java】--网络编程:基于TCP协议的网络通信

    TCP协议(Transmission Control Protocol),即传输控制协议,是一种 面向连接 的, 可靠 的,基于 字节流 的传输层通信协议。数据大小无限制。 建立连接的过程需要 三次握手 。 断开连接的过程需要 四次挥手 。 使用TCP协议的通信双方分别为 客户端 和 服务器端 。 客户端负责向服务

    2024年01月23日
    浏览(58)
  • 用netty轻松实现一个高效稳定的TCP服务器

              随着物联网的发展,很多项目都开始涉及到了tcp连接这块,在这里我们轻松用netty去实现,站在巨人的肩膀上。 关于netty包引用: 实现TCP服务器代码 依赖netty只需几行代码tcp服务:  业务处理代码(参考) 以下是处理报文业务类可参考,注意代码未优化:  运行

    2024年02月22日
    浏览(43)
  • Java网络编程 - TCP通信

    快速入门(一发一收) TCP协议回顾 : TCP是一种面向连接,安全、可靠的传输数据的协议 传输前,采用“三次握手”方式,点对点通信,是可靠的 在连接中可进行大数据量的传输 TCP通信模式 : 在java中只要是使用java.net.Socket类实现通信,底层即是使用了TCP协议 编写客户端代码

    2024年01月19日
    浏览(47)
  • Java中网络的基本介绍。网络通信,网络,ip地址,域名,端口,网络通信协议,TCP/IP传输过程,网络通信协议模型,TCP协议,UDP协议

    - 网络通信 概念:网络通信是指 通过计算机网络进行信息传输的过程 ,包括数据传输、语音通话、视频会议等。在网络通信中,数据被分成一系列的数据包,并通过网络传输到目的地。在数据传输过程中,需要确保数据的完整性、准确性和安全性。常见的网络通信协议有T

    2024年02月10日
    浏览(68)
  • 【Java 网络编程】网络通信原理、TCP、UDP 回显服务

    互联网从何而来? 这要追溯到上个世纪 50 - 60 年代,当时正逢美苏争霸冷战, 核武器 给战争双方提供了足够的威慑力,想要保全自己,就要保证自己的 反制手段 是有效的。 如何保证能够反击: 保存指挥机构 保存核弹头和发射井 指挥机构和核弹头之间的通信链路 需要保证

    2023年04月10日
    浏览(47)
  • 【Java万花筒】通往高效通信的道路:揭秘Java网络库的奥秘

    Java网络通信是构建分布式系统和构想强大网络应用的核心要素。本文将深入探讨几个重要的Java网络通信库,从基础的Socket到高性能的Netty、灵活的Apache MINA、现代的gRPC,以及通用的OkHttp。通过对每个库的介绍和简单示例,读者将能够更好地理解它们的特性、适用场景和如何在

    2024年01月21日
    浏览(50)
  • 数据帧、IP数据包、TCP、UDP报文格式详解----网络通信原理

    物理层是TCP/IP模型的最底层,物理层定义其设备的 物理特性、电气特性 等,比如 网络接口卡、中继器、集线器、网线、无线电 。 物理层作用确保设备之间连接正常,包括建立、维护和断开物理连接等,物理层传输数据是通过电信号中的高低电压和低电压,也就是0101010的比

    2024年02月02日
    浏览(141)
  • Qt实现TCP网络通信

    在标准C++中没有提供专门用于套接字通信的类,所以只能使用操作系统提供的基于C语言的API函数,基于这些C的API函数我们也可以封装自己的C++类。或者我们可以使用Qt框架,它提供了用于套接字通信的类(TCP、UDP)这样我们就可以直接调用相关API即可。 使用Qt提供的类进行基于

    2024年04月17日
    浏览(41)
  • Qt 实现简单的tcp网络通信

    背景: 最近计网要结课了,匆忙之间有个计网实验还没做。 上网这里查查那里查查,随便搞搞 然后在 这篇文章里找到了能够实现的代码 自己想着把它图形化一下,最后在超级棒棒糖的帮助下实现了。 工具头文件tool.h 该头文件用于添加一些要用到的库,直接引用这个库,比

    2024年02月01日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包