Client multi-protocol connection pool method

Abstract

The invention provides a client multi-protocol connection pool method. The client multi-protocol connection pool method comprises the following steps: defining a uniform connection interface; connection of specific protocols is realized; creating a plug-in manager; creating a connection pool: defining a ConnectionPool structural body for managing multiplexing of the connection, creating a connection pool instance by implementing a NewConnectionPool function, obtaining the connection from the pool by implementing a Get method, and putting the connection back to the pool by implementing a Put method; and using the connection pool: creating a plug-in manager instance, registering a protocol connection factory, creating a connection pool instance, acquiring connection from the pool, performing data transmission by using the connection, and putting the connection back to the pool after the data transmission is completed. The system has remarkable advantages in the aspects of flexibility, performance, usability, stability and the like, the expandability and the adaptability of the system are improved, the development cost and the maintenance difficulty are reduced, and more efficient, stable and secure communication services are provided for users.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a method for a client multi-protocol connection pool. Background Art

[0002] In modern distributed systems, communication between clients and servers plays a vital role. With the rapid development of information technology, the types of communication protocols that clients need to support are becoming more and more diverse, including but not limited to HTTP, HTTPS, WebSocket, and gRPC, etc., to meet diverse application scenarios and user needs. However, traditional client communication modes are often limited to a single protocol stack, such as TCP / IP, which greatly restricts the flexibility and scalability of the system.

[0003] Faced with the increasing demand for multi-protocol support, especially in emerging fields such as microservice architecture, IoT devices, and big data processing systems, developers are facing unprecedented challenges. They usually need to carefully design specific connection management logic for each protocol. This approach not only greatly increases the complexity and maintenance cost of the code, but may also lead to uneven resource allocation and performance degradation, thus affecting the stability and efficiency of the entire system.

[0004] In order to solve this problem, a variety of technical solutions have emerged in the market, but each solution has its own limitations. Among them, the single protocol stack solution has won the favor of some developers for its simplicity, clarity, ease of implementation and maintenance. However, its inherent shortcomings such as poor flexibility and limited scalability make it difficult to adapt to the complex environment where multiple protocols coexist.

[0005] Compared with a single protocol stack, a multi-protocol library solution provides a wider range of support. Take libcurl as an example. This open source library can easily handle multiple protocols such as HTTP, FTP, SMTP, etc., greatly reducing the repetitive work of developers. However, the interface design of multi-protocol libraries is often more complex and the learning cost is higher. At the same time, there are certain deficiencies in performance optimization, which makes it difficult to meet the needs of high-performance applications.

[0006] In addition, middleware solutions such as Apache Kafka and RabbitMQ provide message queue and message proxy functions to achieve message forwarding and decoupling between different protocols. This solution effectively improves the flexibility and scalability of the system. However, it also introduces an additional middle layer, which increases the complexity and latency of the system; at the same time, the configuration and management of the middleware are relatively cumbersome, which places higher demands on the technical level of developers.

[0007] In summary, although the existing technical solutions have made some progress in multi-protocol support, there are still many shortcomings. Therefore, there is an urgent need for a more efficient, flexible and easy-to-maintain client multi-protocol connection pool method to cope with increasingly complex and changing communication needs. Summary of the invention

[0008] The object of the present invention is to provide a method for a client multi-protocol connection pool that is efficient, flexible and easy to maintain, so as to solve the problems existing in the prior art.

[0009] The present invention achieves the above-mentioned purpose through the following technical solutions:

[0010] A method for a client multi-protocol connection pool, comprising:

[0011] Define a unified connection interface: By defining a common Connection interface, the interface contains methods for performing basic connection operations, which at least include: Connect for establishing a connection, Send for sending data, Receive for receiving data, and Close for closing a connection;

[0012] Implementing connections for specific protocols: Based on the unified connection interface, implementing specific connection classes for different protocols, each class implements the Connection interface respectively, and each specific connection class corresponds to a specific network protocol;

[0013] Create a plugin manager: define a PluginManager structure to manage connection factories of different protocols, register a new protocol connection factory by implementing the Register method, and obtain the connection factory of the specified protocol by implementing the GetFactory method;

[0014] Create a connection pool: define a ConnectionPool structure to manage connection reuse, create a connection pool instance by implementing the NewConnectionPool function, get a connection from the pool by implementing the Get method, and put the connection back to the pool by implementing the Put method;

[0015] Use the connection pool: create a plug-in manager instance, register the protocol connection factory, create a connection pool instance, obtain a connection from the pool, use the connection for data transmission, and return the connection to the pool when completed.

[0016] A client multi-protocol connection pool method provided by the present invention also includes exception handling and resource management steps:

[0017] Exception capture step: when executing any step of the connection operation, data sending, and data receiving process, set up an exception capture mechanism to capture the exception that occurs;

[0018] Exception handling step: when an exception is caught, the predetermined exception handling logic is executed, and whether to continue subsequent operations is determined according to the exception type;

[0019] Resource cleanup step: When an exception occurs and the operation cannot continue or the program exits normally, it traverses all established connections to ensure that each connection is closed correctly and releases all resources related to the connection to prevent resource leaks.

[0020] According to a client multi-protocol connection pool method provided by the present invention, the method Send for sending data further includes:

[0021] The data encapsulation step encapsulates the data to be sent according to a predetermined protocol format to form a data packet that complies with the communication specification;

[0022] Sending preparation step: before sending a data packet, check whether the connection status is in a sendable state and ensure the integrity and correctness of the data packet;

[0023] The data sending step sends the encapsulated data packet to the target device through the established connection.

[0024] According to a client multi-protocol connection pool method provided by the present invention, the specific connection class at least includes:

[0025] TCPConnection class, used to implement TCP protocol connection;

[0026] UDPConnection class, used to implement UDP protocol connection;

[0027] HTTPConnection class, used to implement HTTP protocol connection;

[0028] The gRPCConnection class is used to implement the gRPC protocol connection.

[0029] According to a client multi-protocol connection pool method provided by the present invention, the PluginManager structure specifically includes:

[0030] A Register method for registering a new protocol connection factory so that the PluginManager can identify and create connections of the new protocol type; the Register method associates the new protocol connection factory with the corresponding protocol type and stores it in the internal data structure of the PluginManager;

[0031] A GetFactory method, according to the specified protocol type, searches and returns the corresponding connection factory in the internal data structure of PluginManager; the GetFactory method is used to enable the external to obtain the corresponding connection factory according to the protocol type, and create a connection instance of a specific protocol type through the factory.

[0032] According to a client multi-protocol connection pool method provided by the present invention, the ConnectionPool structure specifically includes:

[0033] A NewConnectionPool constructor, used to initialize and create a connection pool instance, which is used to manage and maintain a set of available connections;

[0034] A Get method is used to obtain a currently available connection from the connection pool. When there is an idle connection in the connection pool, the Get method returns an idle connection for the user to use. If there is no idle connection in the connection pool, the user can choose to wait for an idle connection, create a new connection, or return an error message according to the system settings.

[0035] A Put method is used to put a used connection back into the connection pool so that subsequent connection requests can reuse the connection. The Put method is used to ensure that the returned connection is in a usable state and perform necessary connection status checks and resource recycling.

[0036] According to a client multi-protocol connection pool method provided by the present invention, the ConnectionPool structure also includes a function for monitoring the connection status, specifically including:

[0037] Monitor the activity of the connection by periodically or in real time checking whether the connection is active, so as to identify and handle idle connections that have not been used for a long time or abnormally disconnected connections;

[0038] Monitor the frequency of connection usage, record and analyze the number of times each connection is used and the duration of use, so as to optimize the configuration and management strategy of the connection pool;

[0039] Monitor the connection for abnormalities, and detect and handle abnormalities in the connection by detecting the connection's error logs, abnormal events, or performance indicators.

[0040] According to a client multi-protocol connection pool method provided by the present invention, the PluginManager structure also includes functions for managing and maintaining a list of registered protocol connection factories, specifically including:

[0041] Maintain a list of registered protocol connection factories, which stores information of all protocol connection factories registered through the Register method;

[0042] Provides a query function for the list, so that external parties can query the information of the registered protocol connection factory as needed;

[0043] Provides a function to update the list. When a new protocol connection factory is registered or the existing factory information changes, the relevant information in the list is updated in real time.

[0044] Provides a list deletion function. When a protocol connection factory is no longer needed, delete the factory information from the list.

[0045] According to a client multi-protocol connection pool method provided by the present invention, creating a plug-in manager instance specifically includes:

[0046] Provide a constructor or factory method for creating a PluginManager instance, which initializes the PluginManager structure and prepares it to manage and maintain a list of registered protocol connection factories;

[0047] After the PluginManager instance is created, a Register method calling interface is provided to allow external parties to register new protocol connection factories with the PluginManager through this interface;

[0048] When registering a protocol connection factory, receive relevant information about the protocol connection factory through the Register method;

[0049] PluginManager stores the received protocol connection factory information in the list of registered protocol connection factories and associates it with the corresponding protocol type so that the corresponding connection factory can be obtained according to the protocol type through the GetFactory method later.

[0050] According to a client multi-protocol connection pool method provided by the present invention, creating a connection pool instance specifically includes:

[0051] Provide a constructor or factory method for creating a ConnectionPool instance, which initializes the ConnectionPool structure and sets the basic parameters of the connection pool;

[0052] When a connection needs to be established for data transmission, the Get method of the ConnectionPool instance is called to obtain a currently available connection from the connection pool; if there is no idle connection in the connection pool, the system settings can be used to choose to wait for an idle connection, create a new connection, or return an error message;

[0053] Use the acquired connection for data transmission. After the data transmission is completed, call the Put method of the ConnectionPool instance to put the used connection back into the connection pool so that subsequent connection requests can reuse the connection.

[0054] It can be seen that compared with the prior art, the present invention has the following beneficial effects:

[0055] 1. The present invention realizes the unified management and use of various specific protocol connections by defining a universal Connection interface. This design enables the system to easily cope with the emergence of new protocols by dynamically loading new protocol connection factories through a plug-in management mechanism without making a lot of modifications to the existing code, which greatly improves the scalability and adaptability of the system.

[0056] 2. The present invention introduces a connection pool management mechanism, which significantly reduces the overhead of connection establishment and disconnection by effectively reusing connection resources. This not only improves the response speed of the system, but also reduces resource consumption, thereby improving overall performance. This performance improvement is particularly obvious in scenarios where frequent connections need to be established.

[0057] 3. The present invention provides a concise and clear interface design, which reduces the learning cost and maintenance difficulty of developers. At the same time, through efficient performance optimization strategies, it ensures the stable operation of the system under high load. This allows developers to focus more on the implementation of business logic without paying too much attention to the complexity of underlying connection management.

[0058] 4. The present invention is equipped with a complete exception handling mechanism and resource management strategy. When an abnormal situation occurs, the system can capture and handle errors in time to avoid resource leakage and program crashes. At the same time, through reasonable resource management, the stability and security of the system are ensured, providing users with reliable service guarantees.

[0059] In summary, the client multi-protocol connection pool method proposed in the present invention shows significant advantages in flexibility, performance, ease of use and stability. It not only improves the scalability and adaptability of the system, but also reduces development costs and maintenance difficulties, providing users with more efficient, stable and secure communication services.

[0060] The present invention is further described in detail below in conjunction with the accompanying drawings and specific embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0061] Figure 1 The present invention is a flowchart of a method embodiment of a client multi-protocol connection pool.

[0062] Figure 2It is a flow diagram of a method embodiment of a client multi-protocol connection pool of the present invention. DETAILED DESCRIPTION

[0063] In order to make the purpose, technical solution and advantages of the present invention clearer, the technical solution of the present invention will be clearly and completely described below in conjunction with the drawings of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0064] Reference to "embodiments" herein means that a particular feature, structure, or characteristic described in conjunction with the embodiments may be included in at least one embodiment of the present application. The appearance of the phrase in various locations in the specification does not necessarily refer to the same embodiment, nor is it an independent or alternative embodiment that is mutually exclusive with other embodiments. It is explicitly and implicitly understood by those skilled in the art that the embodiments described herein may be combined with other embodiments.

[0065] See also Figure 1 and Figure 2 This embodiment provides a method for a client multi-protocol connection pool, including the following steps:

[0066] Step S1, defining a unified connection interface: by defining a general Connection interface, the interface includes methods for performing basic connection operations, the methods at least include: Connect for establishing a connection, Send for sending data, Receive for receiving data, and Close for closing a connection.

[0067] Step S2, realizing the connection of the specific protocol: according to the unified connection interface, realizing the specific connection classes of different protocols, each class realizing the Connection interface respectively, and each specific connection class corresponding to a specific network protocol.

[0068] Step S3, create a plug-in manager: define a PluginManager structure to manage connection factories of different protocols, register a new protocol connection factory by implementing the Register method, and obtain the connection factory of the specified protocol by implementing the GetFactory method.

[0069] Step S4, creating a connection pool: defining a ConnectionPool structure for managing connection reuse, creating a connection pool instance by implementing the NewConnectionPool function, obtaining a connection from the pool by implementing the Get method, and putting the connection back into the pool by implementing the Put method.

[0070] Step S5, using the connection pool: creating a plug-in manager instance, registering the protocol connection factory, creating a connection pool instance, obtaining a connection from the pool, using the connection for data transmission, and returning the connection to the pool after completion.

[0071] Step S6, exception handling and resource management step:

[0072] Exception capture step: when executing any step of the connection operation, data sending, and data receiving process, set up an exception capture mechanism to capture the exception that occurs;

[0073] Exception handling step: when an exception is caught, the predetermined exception handling logic is executed, including but not limited to recording the exception information, attempting to restore the connection or retry the operation, and deciding whether to continue the subsequent operation according to the exception type;

[0074] Resource cleanup step: When an exception occurs and the operation cannot continue or the program exits normally, it traverses all established connections to ensure that each connection is closed correctly and releases all resources related to the connection to prevent resource leaks.

[0075] Among them, the exception capture step and the exception handling step ensure that the program can run stably when encountering an exception, and restore or record the abnormal state as much as possible, while the resource cleanup step ensures that all resources can be properly cleaned up when the program exits or the operation is interrupted to avoid resource leakage problems.

[0076] In the above step S1, the method for sending data further includes:

[0077] The data encapsulation step encapsulates the data to be sent according to a predetermined protocol format to form a data packet that complies with the communication specification;

[0078] Sending preparation step: before sending a data packet, check whether the connection status is in a sendable state and ensure the integrity and correctness of the data packet;

[0079] The data sending step sends the encapsulated data packet to the target device through the established connection.

[0080] Among them, the data encapsulation step and the sending preparation step are prerequisites for ensuring that the data can be sent to the target device accurately and efficiently, and the data sending step is executed after the Connect method for establishing a connection successfully establishes a connection.

[0081] In the above step S2, the specific connection class includes at least:

[0082] TCPConnection class is used to implement TCP protocol connection, including TCP protocol-specific connection establishment, data transmission, and connection closing functions;

[0083] UDPConnection class, used to implement UDP protocol connection, including UDP protocol-specific datagram sending and receiving functions;

[0084] HTTPConnection class is used to implement HTTP protocol connection, including HTTP request sending, response receiving, and session management functions;

[0085] The gRPCConnection class is used to implement gRPC protocol connections, including gRPC-specific service calls, message serialization and deserialization, and other functions.

[0086] Among them, the TCPConnection class, UDPConnection class, HTTPConnection class and gRPCConnection class all implement the above-mentioned general Connection interface, so that these specific protocol connections can be managed and used under a unified framework, improving the flexibility and scalability of the system.

[0087] In the above step S3, the PluginManager structure specifically includes:

[0088] A Register method is used to register a new protocol connection factory so that PluginManager can identify and create connections of new protocol types; the Register method associates the new protocol connection factory with the corresponding protocol type and stores it in the internal data structure of PluginManager;

[0089] A GetFactory method, according to the specified protocol type, searches and returns the corresponding connection factory in the internal data structure of PluginManager; the GetFactory method is used to enable the external to obtain the corresponding connection factory according to the protocol type, and create a connection instance of a specific protocol type through the factory.

[0090] Among them, the Register method and the GetFactory method together constitute the core functions of the PluginManager structure, enabling the system to flexibly expand and support connections of multiple protocol types, thus improving the scalability and versatility of the system. ”

[0091] In the above step S4, the ConnectionPool structure specifically includes:

[0092] A NewConnectionPool constructor, used to initialize and create a connection pool instance, which is used to manage and maintain a set of available connections;

[0093] A Get method is used to obtain a currently available connection from the connection pool. When there is an idle connection in the connection pool, the Get method returns an idle connection for the user to use. If there is no idle connection in the connection pool, the user can choose to wait for an idle connection, create a new connection, or return an error message according to the system settings.

[0094] A Put method is used to put a used connection back into the connection pool so that subsequent connection requests can reuse the connection. The Put method is used to ensure that the returned connection is in a usable state and perform necessary connection status checks and resource recycling.

[0095] Among them, the NewConnectionPool constructor, Get method and Put method together constitute the core functions of the ConnectionPool structure, enabling the system to effectively manage and reuse connection resources and improve system performance and resource utilization efficiency.

[0096] In this embodiment, the ConnectionPool structure also includes functions for monitoring the connection status, specifically including:

[0097] Monitor the activity of the connection by periodically or in real time checking whether the connection is active, so as to identify and handle idle connections that have not been used for a long time or abnormally disconnected connections;

[0098] Monitor the frequency of connection usage, record and analyze the number of times each connection is used and the duration of use, so as to optimize the configuration and management strategy of the connection pool and improve the utilization efficiency of connection resources;

[0099] Monitor the connection for abnormalities. By detecting the connection's error logs, abnormal events, or performance indicators, timely discover and handle abnormalities in the connection to ensure the stability and reliability of the connection.

[0100] Among them, the function of monitoring the connection status is integrated with other functions of the ConnectionPool structure, together forming a comprehensive management and monitoring mechanism for the connection pool, enabling the system to grasp the status and usage of the connection in real time, effectively prevent and handle connection-related problems, and improve system stability and availability.

[0101] In this embodiment, the PluginManager structure also includes functions for managing and maintaining a list of registered protocol connection factories, specifically including:

[0102] Maintain a list of registered protocol connection factories, which stores the information of all protocol connection factories registered through the Register method, including protocol type, factory name, factory instance, etc.

[0103] Provides a query function for the list, so that the outside can query the information of the registered protocol connection factory as needed, so as to understand the protocol types currently supported by the system and the corresponding connection factories;

[0104] Provides a list update function. When a new protocol connection factory is registered or the existing factory information changes, the relevant information in the list can be updated in real time to ensure the accuracy and completeness of the list;

[0105] Provides a list deletion function. When a protocol connection factory is no longer needed, delete the factory information from the list to release resources and simplify management.

[0106] Among them, the functions of managing and maintaining the list of registered protocol connection factories are integrated with other functions of the PluginManager structure, together forming a comprehensive management and maintenance mechanism for the plug-in manager, enabling the system to flexibly manage and expand protocol connection factories, thereby improving the scalability and maintainability of the system.

[0107] In this embodiment, creating a plug-in manager instance specifically includes:

[0108] Provide a constructor or factory method for creating a PluginManager instance, which initializes the PluginManager structure and prepares it to manage and maintain a list of registered protocol connection factories;

[0109] After the PluginManager instance is created, a Register method calling interface is provided to allow external parties to register new protocol connection factories with the PluginManager through this interface;

[0110] When registering a protocol connection factory, the Register method is used to receive relevant information about the protocol connection factory, including but not limited to the protocol type, factory name, and factory method or function pointer for creating a connection instance;

[0111] PluginManager stores the received protocol connection factory information in the list of registered protocol connection factories and associates it with the corresponding protocol type so that the corresponding connection factory can be obtained according to the protocol type through the GetFactory method later.

[0112] Among them, the steps of creating a plugin manager instance and registering a protocol connection factory cooperate with other functions of the PluginManager structure, so that the system can flexibly expand and support connections of multiple protocol types, improving the scalability and flexibility of the system.

[0113] In this embodiment, creating a connection pool instance specifically includes:

[0114] Provide a constructor or factory method for creating a ConnectionPool instance, which initializes the ConnectionPool structure and sets the basic parameters of the connection pool, such as the maximum number of connections, connection timeout, etc.

[0115] When a connection needs to be established for data transmission, the Get method of the ConnectionPool instance is called to obtain a currently available connection from the connection pool; if there is no idle connection in the connection pool, the system settings can be used to choose to wait for an idle connection, create a new connection, or return an error message;

[0116] Use the acquired connection to perform data transmission, including but not limited to sending data requests, receiving data responses, and handling exceptions during data transmission;

[0117] After the data transmission is completed, call the Put method of the ConnectionPool instance to put the used connection back into the connection pool so that subsequent connection requests can reuse the connection; the Put method ensures that the returned connection is in an available state, and performs necessary connection status checks and resource recycling.

[0118] Among them, the steps of creating a connection pool instance, obtaining a connection from the pool, using the connection for data transmission, and putting the connection back into the pool cooperate with the functions of the ConnectionPool structure to achieve efficient management and reuse of connections, and improve the resource utilization efficiency and performance of the system.

[0119] In summary, the client multi-protocol connection pool method proposed in the present invention shows significant advantages in flexibility, performance, ease of use and stability, which not only improves the scalability and adaptability of the system, but also reduces development costs and maintenance difficulties, providing users with more efficient, stable and secure communication services.

[0120] Furthermore, the present invention realizes the unified management and use of various specific protocol connections by defining a universal Connection interface. This design enables the system to easily cope with the emergence of new protocols by dynamically loading new protocol connection factories through a plug-in management mechanism without making a lot of modifications to the existing code, which greatly improves the scalability and adaptability of the system.

[0121] Furthermore, the present invention introduces a connection pool management mechanism, which significantly reduces the overhead of connection establishment and disconnection by effectively reusing connection resources. This not only improves the response speed of the system, but also reduces resource consumption, thereby improving overall performance. This performance improvement is particularly obvious in scenarios where frequent connections need to be established.

[0122] Furthermore, the present invention provides a concise and clear interface design, which reduces the learning cost and maintenance difficulty of developers. At the same time, through an efficient performance optimization strategy, the stable operation of the system under high load is ensured. This allows developers to focus more on the implementation of business logic without paying too much attention to the complexity of underlying connection management.

[0123] Furthermore, the present invention is equipped with a complete exception handling mechanism and resource management strategy. When an abnormal situation occurs, the system can capture and handle errors in a timely manner to avoid resource leakage and program crashes. At the same time, through reasonable resource management, the stability and security of the system are ensured, providing users with reliable service guarantees.

[0124] The technical features of the above embodiments may be arbitrarily combined. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0125] The above-mentioned embodiments are only preferred embodiments of the present invention and cannot be used to limit the scope of protection of the present invention. Any non-substantial changes and substitutions made by technicians in this field on the basis of the present invention shall fall within the scope of protection required by the present invention.

Claims

1. A method for client multi-protocol connection pool, characterized in that: The following steps are involved: Define a unified connection interface: By defining a common Connection interface, the interface contains methods for performing basic connection operations, which at least include: Connect for establishing a connection, Send for sending data, Receive for receiving data, and Close for closing a connection; Implementing connections for specific protocols: Based on the unified connection interface, implementing specific connection classes for different protocols, each class implements the Connection interface respectively, and each specific connection class corresponds to a specific network protocol; Create a plugin manager: define a PluginManager structure to manage connection factories of different protocols, register a new protocol connection factory by implementing the Register method, and obtain the connection factory of the specified protocol by implementing the GetFactory method; Create a connection pool: define a ConnectionPool structure to manage connection reuse, create a connection pool instance by implementing the NewConnectionPool function, get a connection from the pool by implementing the Get method, and put the connection back to the pool by implementing the Put method; Use the connection pool: create a plug-in manager instance, register the protocol connection factory, create a connection pool instance, obtain a connection from the pool, use the connection for data transmission, and return the connection to the pool when completed.

2. The method according to claim 1, characterized in that It also includes exception handling and resource management steps: Exception capture step: when executing any step of the connection operation, data sending, and data receiving process, set up an exception capture mechanism to capture the exception that occurs; Exception handling step: when an exception is caught, the predetermined exception handling logic is executed, and whether to continue subsequent operations is determined according to the exception type; Resource cleanup step: When an exception occurs and the operation cannot continue or the program exits normally, it traverses all established connections to ensure that each connection is closed correctly and releases all resources related to the connection to prevent resource leaks.

3. The method according to claim 1, characterized in that The Send method for sending data further includes: The data encapsulation step encapsulates the data to be sent according to a predetermined protocol format to form a data packet that complies with the communication specification; Sending preparation step: before sending a data packet, check whether the connection status is in a sendable state and ensure the integrity and correctness of the data packet; The data sending step sends the encapsulated data packet to the target device through the established connection.

4. The method according to claim 1, characterized in that: The specific connection class includes at least: TCPConnection class, used to implement TCP protocol connection; UDPConnection class, used to implement UDP protocol connection; HTTPConnection class, used to implement HTTP protocol connection; The gRPCConnection class is used to implement the gRPC protocol connection.

5. The method according to claim 1, characterized in that: The PluginManager structure specifically includes: A Register method for registering a new protocol connection factory so that the PluginManager can identify and create connections of the new protocol type; the Register method associates the new protocol connection factory with the corresponding protocol type and stores it in the internal data structure of the PluginManager; A GetFactory method, according to the specified protocol type, searches and returns the corresponding connection factory in the internal data structure of PluginManager; the GetFactory method is used to enable the external to obtain the corresponding connection factory according to the protocol type, and create a connection instance of a specific protocol type through the factory.

6. The method according to claim 1, characterized in that: The ConnectionPool structure specifically includes: A NewConnectionPool constructor, used to initialize and create a connection pool instance, which is used to manage and maintain a set of available connections; A Get method is used to obtain a currently available connection from the connection pool. When there is an idle connection in the connection pool, the Get method returns an idle connection for the user to use. If there is no idle connection in the connection pool, the user can choose to wait for an idle connection, create a new connection, or return an error message according to the system settings. A Put method is used to put a used connection back into the connection pool so that subsequent connection requests can reuse the connection. The Put method is used to ensure that the returned connection is in a usable state and perform necessary connection status checks and resource recycling.

7. The method according to claim 6, characterized in that: The ConnectionPool structure also includes functions for monitoring the connection status, including: Monitor the activity of the connection by periodically or in real time checking whether the connection is active, so as to identify and handle idle connections that have not been used for a long time or abnormally disconnected connections; Monitor the frequency of connection usage, record and analyze the number of times each connection is used and the duration of use, so as to optimize the configuration and management strategy of the connection pool; Monitor the connection for abnormalities, and detect and handle abnormalities in the connection by detecting the connection's error logs, abnormal events, or performance indicators.

8. The method according to any one of claims 1 to 7, characterized in that: The PluginManager structure also includes functions for managing and maintaining a list of registered protocol connection factories, including: Maintain a list of registered protocol connection factories, which stores information of all protocol connection factories registered through the Register method; Provides a query function for the list, so that external parties can query the information of the registered protocol connection factory as needed; Provides a function to update the list. When a new protocol connection factory is registered or the existing factory information changes, the relevant information in the list is updated in real time. Provides a list deletion function. When a protocol connection factory is no longer needed, delete the factory information from the list.

9. The method according to any one of claims 1 to 7, characterized in that: The creation of the plug-in manager instance specifically includes: Provide a constructor or factory method for creating a PluginManager instance, which initializes the PluginManager structure and prepares it to manage and maintain a list of registered protocol connection factories; After the PluginManager instance is created, a Register method calling interface is provided to allow external parties to register new protocol connection factories with the PluginManager through this interface; When registering a protocol connection factory, receive relevant information about the protocol connection factory through the Register method; PluginManager stores the received protocol connection factory information in the list of registered protocol connection factories and associates it with the corresponding protocol type so that the corresponding connection factory can be obtained according to the protocol type through the GetFactory method later.

10. The method according to any one of claims 1 to 7, characterized in that: The creation of a connection pool instance specifically includes: Provide a constructor or factory method for creating a ConnectionPool instance, which initializes the ConnectionPool structure and sets the basic parameters of the connection pool; When a connection needs to be established for data transmission, the Get method of the ConnectionPool instance is called to obtain a currently available connection from the connection pool; if there is no idle connection in the connection pool, the system settings can be used to choose to wait for an idle connection, create a new connection, or return an error message; Use the acquired connection for data transmission. After the data transmission is completed, call the Put method of the ConnectionPool instance to put the used connection back into the connection pool so that subsequent connection requests can reuse the connection.

Images