CN117354117B - Java and MQ-based distributed message communication method and system - Google Patents
Java and MQ-based distributed message communication method and system Download PDFInfo
- Publication number
- CN117354117B CN117354117B CN202311303481.9A CN202311303481A CN117354117B CN 117354117 B CN117354117 B CN 117354117B CN 202311303481 A CN202311303481 A CN 202311303481A CN 117354117 B CN117354117 B CN 117354117B
- Authority
- CN
- China
- Prior art keywords
- message
- server
- client
- java
- communication
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 230000006854 communication Effects 0.000 title claims abstract description 102
- 238000004891 communication Methods 0.000 title claims abstract description 100
- 238000000034 method Methods 0.000 title claims abstract description 40
- 230000007246 mechanism Effects 0.000 claims abstract description 31
- 238000012545 processing Methods 0.000 claims description 28
- 238000004458 analytical method Methods 0.000 claims description 11
- 230000008859 change Effects 0.000 claims description 3
- 238000001514 detection method Methods 0.000 claims description 3
- 230000008569 process Effects 0.000 abstract description 14
- 238000005516 engineering process Methods 0.000 abstract description 8
- 230000005540 biological transmission Effects 0.000 description 20
- 239000000306 component Substances 0.000 description 8
- 238000012795 verification Methods 0.000 description 8
- 238000004590 computer program Methods 0.000 description 5
- 238000011161 development Methods 0.000 description 5
- 230000006870 function Effects 0.000 description 5
- 230000001965 increasing effect Effects 0.000 description 4
- 230000002688 persistence Effects 0.000 description 4
- 230000009286 beneficial effect Effects 0.000 description 3
- 230000004044 response Effects 0.000 description 3
- 238000013475 authorization Methods 0.000 description 2
- 238000012790 confirmation Methods 0.000 description 2
- 239000008358 core component Substances 0.000 description 2
- 230000008878 coupling Effects 0.000 description 2
- 238000010168 coupling process Methods 0.000 description 2
- 238000005859 coupling reaction Methods 0.000 description 2
- 238000012423 maintenance Methods 0.000 description 2
- 238000012544 monitoring process Methods 0.000 description 2
- 230000002085 persistent effect Effects 0.000 description 2
- 238000010586 diagram Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000002708 enhancing effect Effects 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 230000002452 interceptive effect Effects 0.000 description 1
- 238000007726 management method Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 238000011084 recovery Methods 0.000 description 1
- 230000009897 systematic effect Effects 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
Classifications
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L41/00—Arrangements for maintenance, administration or management of data switching networks, e.g. of packet switching networks
- H04L41/04—Network management architectures or arrangements
- H04L41/042—Network management architectures or arrangements comprising distributed management centres cooperatively managing the network
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L47/00—Traffic control in data switching networks
- H04L47/10—Flow control; Congestion control
- H04L47/12—Avoiding congestion; Recovering from congestion
- H04L47/125—Avoiding congestion; Recovering from congestion by balancing the load, e.g. traffic engineering
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L47/00—Traffic control in data switching networks
- H04L47/70—Admission control; Resource allocation
- H04L47/78—Architectures of resource allocation
- H04L47/783—Distributed allocation of resources, e.g. bandwidth brokers
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L51/00—User-to-user messaging in packet-switching networks, transmitted according to store-and-forward or real-time protocols, e.g. e-mail
- H04L51/21—Monitoring or handling of messages
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L61/00—Network arrangements, protocols or services for addressing or naming
- H04L61/30—Managing network names, e.g. use of aliases or nicknames
- H04L61/3015—Name registration, generation or assignment
- H04L61/3025—Domain name generation or assignment
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L69/00—Network arrangements, protocols or services independent of the application payload and not provided for in the other groups of this subclass
- H04L69/22—Parsing or analysis of headers
Landscapes
- Engineering & Computer Science (AREA)
- Computer Networks & Wireless Communication (AREA)
- Signal Processing (AREA)
- Computer Security & Cryptography (AREA)
- Computer And Data Communications (AREA)
Abstract
The invention relates to the technical field of network communication, and provides a distributed message communication method and system based on Java and MQ, which realize high-efficiency communication between a client and a server through SDK of an integrated communication engine and corresponding front-end technology. The system distributes the client request to the back-end Broker cluster by using domain name resolution and load balancing technology, and completes initialization connection through 3 times of handshaking and 4 times of waving. The client terminal subscribes the message through the established communication channel, and the server establishes a corresponding long connection according to the protocol type and processes the message through an internal event distribution mechanism. The message sender delivers the message to the channel subscribed to the topic and RabbitMQ through the Broker cluster, while supporting a message reservation mechanism to compensate for message loss in the off-line state.
Description
Technical Field
The invention relates to the technical field of network communication, in particular to a distributed message communication method and system based on Java and MQ (message queue).
Background
The communication engine is used as a core component of the bottom communication system and is responsible for processing message communication between the client and the server. Communication implementations on the market are usually developed using the C language or Erlang language, which are excellent in terms of performance and concurrency, but have a high development threshold.
Prior art solutions are typically developed using the C language or Erlang language, which results in increased difficulty in development and maintenance. Meanwhile, in the aspect of channel consistency, the prior art scheme generally adopts a ZooKeeper registry or similar distributed synchronization scheme to realize the intercommunication of message channels, which increases the complexity of the system and the message storage of internal data nodes occupies a large amount of resources. Furthermore, these schemes lack a systematic self-compensation mechanism, requiring triggering secondary synchronization or manual intervention by alarm monitoring to handle message problems.
In order to reduce the threshold and the cost, solve the problem that the current Java and MQ technologies can not meet the requirements of real-time performance, reliability and expansibility due to lack of a unified solution when being used for constructing a distributed message communication system, the method and the system for distributed message communication, which use a local cache as a first-level cache, a Redis as a second-level cache and an elastic search as message storage, are required to be provided based on widely used Java language as a technical choice, so as to ensure the efficient processing and the concurrent performance of a message channel, thereby meeting the requirements of optimizing the communication performance and improving the reliability of the system.
Disclosure of Invention
In order to solve the problems, the invention provides a distributed message communication method and system based on Java and MQ, which realize high-efficiency communication between a client and a server through SDK (Software Development Kit ) of an integrated communication engine and corresponding front-end technology, so that the transmission and processing of messages become smoother and more reliable, and quick response and seamless connection communication experience is provided for users.
The invention uses Nginx as dynamic load equalizer to process message forwarding and SSL (Secure Sockets Layer) protocol analysis ability by developing own communication engine as bottom communication system. The message Broker of the back end is realized by Java, a local cache is used as a first-level cache, redis is used as a second-level cache, and an elastic search is used as a physical storage to realize the reading and storage of the message. The message distribution aspect uses RabbitMQ as a message component to simulate the message synchronization mode of a registry.
In order to achieve the above purpose, the present invention provides the following technical solutions:
In a first aspect, the present invention provides a distributed message communication system based on Java and MQ, including a client and a server, where an APP of the client integrates an SDK of a communication engine, and a web client integrates JS (JavaScript) of the communication engine, for communication with the server; the server side comprises:
One or more domain name resolution servers for resolving domain names into corresponding IP addresses;
One or more nmginx servers for realizing load balancing and request distribution, wherein the nmginx servers are also used for distributing requests from the client to a Broker cluster at the back end according to a preset load balancing algorithm; the domain name resolution server and the Nginx server are communicated with the back-end Broker cluster through network connection; the domain name resolution server and the Nginx server are also used for dynamically adjusting a load balancing strategy according to the change of the system load.
As a further scheme of the present invention, the nginix server is further used for fault detection and fault switching, and when a certain server in the back-end Broker cluster fails, the nginix server is further used for automatically switching the request forwarding to a normally working server.
As a further scheme of the present invention, the client is connected to the server through a domain name, the server is further configured to perform IP address resolution through a domain name resolution server, and distribute the IP address resolution to a ngginx server, the ngginx server distributes a request to a Broker cluster at a back end by using a load balancing algorithm, and after the Broker cluster receives the request, the Broker cluster completes initialization connection through a 3-way handshake and a 4-way handshake.
As a further scheme of the present invention, the server converts the client request into an IP address through domain name resolution, and distributes the request to the Broker cluster of the back end through a load balancer, where the nmginx server acts as the load balancer.
In the distributed message communication system based on Java and MQ, the client terminal subscribes to the message by establishing a communication channel, the server terminal is used for establishing a corresponding long connection according to the message protocol type, and processes and records the message by an internal event distribution mechanism, wherein the processing and recording of the message comprises a local cache, a Redis cache and an elastic search cache.
As a further scheme of the present invention, the Broker cluster is further configured to check whether a channel subscribed to a certain topic exists, and if so, first transmit a message to the channel, then forward the message to a message flow queue in RabbitMQ, rabbitMQ, and after receiving the message, forward the message to a Broker application host in the Broker cluster according to a set identifier.
As a further scheme of the invention, the distributed message communication system based on Java and MQ further comprises a message reservation and compensation mechanism, and when the Broker cluster transmits the message to the channel, if the receiving end of the rabitmq is not connected, the client as the sender saves the message in dis and elastic search; after the receiving end of RabbitMQ is reconnected, the Java and MQ based distributed message communication system retrieves the saved messages in Redis and elastic search and sends the messages to the receiving end to complete a message compensation mechanism.
As a further scheme of the present invention, the message compensation mechanism includes multiple attempts to send unsuccessful messages, and records the unsuccessful messages in the personal session after a set number of attempts, and when the receiving end is reconnected, the system retries to send the recorded unsuccessful messages to complete the compensation of the messages, wherein the message compensation mechanism compensates according to the set number of retries and the time interval.
As a further scheme of the invention, the message transmission and processing in the distributed message communication system based on Java and MQ are realized through Java programming language, local buffer memory is used as a first-level buffer memory, redis is used as a second-level buffer memory, and elastic search is used as physical storage to realize the reading and storage of the message, and RabbitMQ is used as a message component to carry out broadcast-like message distribution.
In a second aspect, the present invention also provides a distributed message communication method based on Java and MQ, including the following steps:
a. integrating the JS of the communication engine at the SDK of the communication engine at the client or the webpage version client;
b. the client is connected with the server through a domain name, and the server completes IP address resolution through domain name resolution;
c. the server side uses Nginx to carry out load balancing and distributes the load balancing to the Broker cluster at the back end;
d. The client establishes a communication channel with the server, and completes initialization connection through 3 times of handshake and 4 times of waving;
e. the client sends a subscription request, and the interested message theme is appointed;
f. the server receives the subscription request, and performs protocol analysis and establishment of long connection;
g. The server distributes according to the message theme, and sends the message to the corresponding consumer by using a consistency hash algorithm or a load balancing strategy; the server distributes and records the message through an event mechanism, wherein the message comprises a local cache, a Redis cache and a ES (Elasticsearch) cache;
h. The client sends a message to a browser cluster aiming at a subscribed topic, the browser cluster addresses a channel corresponding to the subscribed topic in the local machine and transmits the channel to a RabbitMQ, and the channel is transmitted to an application host of a Broker in the next cluster after an identifier is added, wherein if the message has a unique identifier of RabbitMq, the channel is not transmitted after the local machine consumes;
i. If the receiving end goes offline, the message remains in Redis and ES until the receiving end reconnects.
As a further scheme of the invention, the client uses Java written application programs, and the server uses MQ to realize the receiving, distributing and forwarding of the messages; message passing and processing are realized through Java programming language, local buffer memory is used as first-level buffer memory, redis is used as second-level buffer memory, and elastic search is used as physical storage to realize reading and storage of messages, and RabbitMQ is used as message component to carry out broadcast-like message distribution.
In a third aspect, the present invention provides a computer device comprising a memory storing a computer program and a processor implementing the steps of a Java and MQ based distributed messaging method when the computer program is loaded and executed by the processor.
In a fourth aspect, the present invention provides a readable storage medium storing a computer program which, when loaded and executed by a processor, implements the steps of the Java and MQ based distributed messaging method.
Compared with the prior art, the distributed message communication method and system based on Java and MQ provided by the invention have the following beneficial effects:
1. Reliability: reliable delivery of messages can be ensured using Message Queues (MQ) as middleware. The message queue has a persistence mechanism, so that the message can be safely stored even if a fault or network interruption occurs in the communication process, the message is persistence and is retransmitted after the system is recovered, the message is ensured not to be lost, and the risk of message loss is avoided.
2. Asynchronous communication: the distributed message communication system adopts an asynchronous communication mode of a message queue, and a sender can continue other operations after sending the message to the queue without waiting for the instant response of a receiver. The asynchronous communication mode improves the throughput and the performance of the system and can better process burst high concurrency requests.
3. Scalability: by using Broker clustering and load balancing techniques, the system can be easily extended to handle larger message traffic and more client connections. By adding new message queue nodes and application hosts and distributing requests to different nodes by using a load balancing technology, the system can realize lateral expansion and improve the scalability and fault tolerance of the system.
4. Decoupling and flexibility: the sender and the receiver are decoupled by using a message queue, and the sender only needs to send the message into the queue, and does not need to know who the specific receiver is. The decoupling property enables the system components to be evolved independently, reduces the coupling degree of the system, and improves the maintainability and expandability of the system.
5. Message reservation and compensation: by storing the messages of the unconnected recipients in the dis and elastic search, the system can resend the messages after the recipients are reconnected, realizing a reservation and compensation mechanism for the messages. This ensures that important messages are not lost even if the recipient is temporarily offline.
6. High availability: by using a Broker cluster and message queues, the system achieves high availability. Even if a certain message queue node or an application host fails, the system can still continue to operate, and the transmission and processing of the message are ensured, so that reliable service is provided.
7. Real-time and concurrency: the distributed messaging system enables real-time messaging and processing by establishing long connections and using asynchronous communication modes. At the same time, the message queue allows multiple consumers to process messages concurrently, thereby improving the concurrency performance of the system. Multiple consumers can independently acquire messages from the queues for processing, so that parallel execution of tasks is realized, and the processing speed of the system is increased.
In summary, java and MQ based distributed messaging methods and systems provide reliable, efficient, scalable messaging mechanisms with decoupling, flexibility, and high availability. The system architecture can meet the communication requirement in a distributed environment, is suitable for a large-scale system and a high concurrency scene, and brings a plurality of beneficial effects.
These and other aspects of the invention will be more readily apparent from the following description of the embodiments. It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the invention as claimed.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following description will briefly introduce the drawings that are needed in the embodiments or the description of the prior art, and it is obvious that the drawings in the following description are only some embodiments of the present invention. In the drawings:
fig. 1 is a diagram of a distributed messaging system architecture based on Java and MQ in accordance with an embodiment of the present invention.
Fig. 2 is a flow chart of a distributed message communication method based on Java and MQ according to an embodiment of the present invention.
Detailed Description
The present invention will be described in further detail with reference to the drawings and examples, in order to make the objects, technical solutions and advantages of the present invention more apparent. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the invention.
In order to reduce the threshold and the cost, the invention solves the problem that the current Java and MQ technology can not meet the requirements of real-time performance, reliability and expansibility because a unified solution is lacking when being used for constructing a distributed message communication system.
In particular, embodiments of the present application are further described below with reference to the accompanying drawings.
As shown in fig. 1, one embodiment of the present invention provides a Java and MQ-based distributed messaging system, the architecture of which includes:
Client side: the client can be an application program written by Java, an SDK integrated with a communication engine or a JS integrated with the communication engine by a webpage client. The SDK refers to a software development kit (Software Development Kit), and the SDK of the communication engine is used as a software package providing tools and resources required for development, and is used for helping developers to construct application programs integrated with the communication engine, including libraries, APIs (application programming interfaces), example codes and documents for connecting, sending and receiving communication related functions such as messages; in this embodiment, the SDK of the communication engine may simplify the work of the developer, so that the developer can use the functions of the communication engine more easily, so as to integrate the communication capability into the application program, and ensure compatibility and interoperability with the engine or the system. The JS refers to JavaScript, which is used as a programming language widely used for webpage development, and is used for enhancing the interactivity and the dynamic property of the webpage, and the JavaScript is used for operating elements on the webpage, responding to the interactive operation of a user, verifying the input of a form, sending and receiving data and the like during webpage development; the function of the communication engine can be embedded into the webpage client, and JavaScript is used for realizing some interaction and functions of the communication engine, so that the webpage and the server can carry out operations such as real-time communication, data transmission and the like, and the real-time property and the interactivity of the webpage are enhanced.
The server side: the server uses MQ (message queue) to implement the receiving, distributing and forwarding of messages. It includes one or more domain name resolution servers, one or more nmginx servers, and a Broker cluster at the back end. The domain name resolution server is used for resolving the domain name into corresponding IP addresses, and the Nginx server is used for realizing load balancing and request distribution and distributing the request of the client to the Broker cluster of the back end according to a preset load balancing algorithm. The domain name resolution server, the Nginx server and the Broker cluster are communicated through network connection, and the domain name resolution server and the Nginx server are also used for dynamically adjusting a load balancing strategy according to the change of the system load.
In this embodiment, the nmginx server is further configured to perform fault detection and fault switching, and when a certain server in the backend Broker cluster fails, the nmginx server is further configured to automatically switch the forwarding of the request to a server that works normally.
The client is connected with the server through a domain name, the server is further used for carrying out IP address resolution through the domain name resolution server and distributing the IP address resolution to the Nginx server, the Nginx server distributes the request to a Broker cluster at the rear end through a load balancing algorithm, and after the Broker cluster receives the request, initialization connection is completed through a 3-time handshake and a 4-time waving mode.
The server converts the client request into an IP address through domain name resolution, and distributes the request to a Broker cluster of the back end through a load balancer, wherein Ngi nx server serves as the load balancer.
In this embodiment, the Broker cluster is used as a set of servers running a message Broker (Broker), where the Broker cluster is used as a core component of a messaging system and is responsible for receiving, storing, routing and transmitting messages, and combines multiple Broker servers together to achieve the goals of high availability, load balancing and fault tolerance, and through the Broker cluster, the advantages of high availability, load balancing, fault tolerance, expansibility, security and high concurrency can be achieved.
Wherein:
when high availability is achieved, the cluster can still work continuously by running a plurality of broaders in the cluster even if one broader fails, so that reliable transmission of messages is ensured. This improves the usability of the system and reduces the risk of service interruption.
When the load balancing is realized, the Broker cluster can balance the load of the messages, and ensure that the messages are uniformly distributed in the cluster. This helps to improve the performance and throughput of the system while avoiding overload of a single node.
When fault tolerance is achieved, if one Broker node fails, the cluster can automatically route the message to other available nodes, so that the message transmission is ensured not to be interrupted. This improves the fault tolerance of the system and reduces the risk of data loss.
When the expansibility is realized, more nodes can be added to the Broker cluster according to the requirement so as to process larger message traffic and more client connections. This allows for a good scalability of the system, which can cope with the ever increasing demands.
When security is implemented, the Broker clusters may provide security functions such as authentication, authorization, and encryption to ensure secure transmission and storage of messages.
When high concurrency is realized, the system can process a plurality of messages in a concurrency way by using a plurality of Broker nodes in the cluster, thereby improving the concurrency performance of the system and accelerating the transmission and processing of the messages.
In summary, the Broker cluster is an important component in the distributed messaging system, and through cooperative work, the Broker cluster provides reliable messaging service, so that the Broker cluster is suitable for various real-time communication and distributed application scenarios.
In this embodiment, in a distributed message communication system based on Java and MQ, a client performs message subscription with a server by establishing a communication channel, where the server is configured to establish a corresponding long connection according to a message protocol type, and process and record a message through an internal event distribution mechanism, where the processing and recording of the message includes a local cache, a Redis cache, and an elastic search cache.
The Broker cluster is further configured to check whether a channel subscribed to a certain topic exists, and if so, transmit the message to the channel, forward the message to a message flow queue in RabbitMQ, rabbitMQ, and forward the message to a Broker application host in the Broker cluster according to a set identifier after the message is received by the message flow queue.
In this embodiment, the distributed message communication system based on Java and MQ further includes a message reservation and compensation mechanism, and when the Broker cluster transmits the message to the channel, if the receiving end of the rabkitmq is not connected, the client side as the sender saves the message in dis and elastic search; after the receiving end of RabbitMQ is reconnected, the Java and MQ based distributed message communication system retrieves the saved messages in Redis and elastic search and sends the messages to the receiving end to complete a message compensation mechanism.
The message compensation mechanism comprises multiple attempts to send unsuccessful messages, records the unsuccessful messages in personal session after the set number of attempts, and when the receiving end is reconnected, the system retries to send the recorded unsuccessful messages to complete the compensation of the messages, wherein the message compensation mechanism compensates according to the set number of retries and the time interval.
In the distributed message communication system based on Java and MQ, the message transmission and processing are realized through Java programming language, local cache is used as a first-level cache, redis is used as a second-level cache, and elastic search is used as physical storage to realize the reading and storage of the message, and RabbitMQ is used as a message component to carry out broadcast-like message distribution.
The distributed message communication system based on Java and MQ of the invention is implemented by the following working principles:
a. client integration: the SDK of the client integrated communication engine or the JS of the webpage client integrated communication engine is used for communicating with the server.
B. Domain name resolution and connection establishment: the client connects with the server through the domain name, the server uses the domain name resolution server to complete the IP address resolution, and distributes the request to the Broker cluster of the back end, wherein the Nginx server is used as a load balancer. And establishing a communication channel between the client and the server through 3 times of handshaking and 4 times of waving, and completing initialization connection.
C. Subscription request and long connection establishment: the client sends a subscription request specifying a message topic of interest. And the server receives the subscription request, and performs protocol analysis and establishment of long connection. And the server sends the message to the corresponding consumer by using a consistent hash algorithm or a load balancing strategy according to the message theme. The server distributes and records the message through an event mechanism, and the message comprises a local cache, a Redis cache and an elastic search cache.
D. Message sending and forwarding: the client sends the message to the server, and the server forwards the message to other Broker clusters through RabbitMQ. When the receiving end goes offline, the message remains in Redis and elastic search until the receiving end reconnects.
E. Message compensation mechanism: the message sent by the client needs to be reserved when the receiving end is not connected. The message is kept in Redis and elastic search, and after the receiving end is reconnected, the message is sent to the client, so that a message compensation mechanism is realized.
In the distributed message communication system based on Java and MQ, popular Java language is used from the aspect of technical selection, in order to ensure concurrency and efficiency, a local cache is used as a first-level cache, redis is used as a second-level cache, ELASTICSEARCH is used as message storage, high-efficiency processing of a message channel is ensured, a inheritance threshold is low, and the optimization speed is high; secondly, the technical scheme uses rabbitmq for class broadcast distribution, the step of message synchronization is eliminated, and compared with real-time heartbeat monitoring and processing, the system load is smaller, and the synchronization speed is faster; on the problem that the processing of the data synchronization fails and the timely compensation processing cannot be performed, the using broadcast-like message is not successfully transmitted and enters a compensation delay queue, the three failures are put into a personal session, the subsequent transmission and the reception can be performed once the connection is performed, the threshold of iterative maintenance is low, the activity of communities is high, the expansibility is strong, and the suitability is strong.
It should be noted that, in this embodiment, after the Broker cluster receives the request, the initialization connection is completed through a 3-way handshake and a 4-way waving manner, where the 3-way handshake includes the following steps:
First handshake: the client sends a data packet with SYN (synchroni ze) marks to the server;
The 2 nd handshake: after the server receives the data packet successfully, a data packet with a SYN/ACK mark is returned to transmit confirmation information, which indicates that the data packet is received;
3 rd handshake: the client transmits back a data packet with an ACK mark, which indicates that I know that the handshake is finished.
Wherein: SYN flag bit number 1, indicating that a TCP connection is established; the ACK flag indicates a verification field.
In this embodiment, the three-way handshake procedure is described in detail as follows:
1. The client sends a request message for establishing the TCP connection, wherein the message contains a seq serial number which is randomly generated by the sender, and the SYN field in the message is set to be 1, which indicates that the TCP connection needs to be established. (syn=1, seq=x, x is a randomly generated value);
2. the server replies a TCP connection request message sent by the client, wherein the message contains a seq sequence number which is randomly generated by the replying terminal, the SYN is set to be 1, an ACK field is generated, and the value of the ACK field is replied by adding 1 on the basis of the sequence number seq sent by the client, so that the client knows that the own TCP establishment request is verified when receiving information. (syn=1, ack=x+1, seq=y, y is a randomly generated value) ack plus 1 here can be understood as an acknowledgement and who established the connection;
3. After receiving the TCP establishment verification request sent by the server, the client will make its own sequence number add 1, and reply to the ACK verification request again, add 1 to the seq sent by the server to reply. (syn=1, ack=y+1, seq=x+1).
Since the TCP connection is full duplex, each direction must be closed separately. The principle is that after a party has completed its data transmission task, it can send an FI N to terminate the connection in this direction. Receipt of an FI N only means that there is no data flow in this direction and a TCP connection can still send data after receipt of an FI N. One party that first performs a shutdown will perform an active shutdown while the other party performs a passive shutdown.
In this embodiment, the 4 times of waving of the hand includes the following steps:
Waving hands for the 1 st time: the client sends a FIN to close the data transmission from the client to the server, and the client enters a fin_wait_1 state;
The 2 nd hand waving: after receiving the FIN, the server sends an ACK to the client to confirm that the sequence number is received sequence number +1 (same as SYN, one FIN occupies one sequence number), and the server enters a close_wait state;
3 rd hand waving: the server sends a FIN to close the data transmission from the server to the client, and the server enters a LAST_ACK state;
The 4 th hand waving: after receiving the FIN, the client t enters a time_wait state, then sends an ACK to the Server, confirms that the sequence number is the received sequence number +1, and the Server enters a CLOSED state to finish four waving operations.
In this embodiment, the process of waving the hand for 4 times is described in detail as follows:
1. The client sends a message of a TCP connection disconnection request, wherein the message contains a seq serial number which is randomly generated by the sender, and the FIN field in the message is set to 1 to indicate that the TCP connection needs to be disconnected. (fin=1, seq=x, x is randomly generated by the client);
2. The server replies a TCP disconnection request message sent by the client, wherein the TCP disconnection request message contains a seq sequence number which is randomly generated by the replying terminal, and an ACK field is generated, and the value of the ACK field is replied by adding 1 on the basis of the seq sequence number sent by the client, so that the client can know that the own TCP disconnection request is verified when receiving information. (fin=1, ack=x+1, seq=y, y is randomly generated by the server);
3. After the server replies the TCP disconnection request of the client, the server does not disconnect the TCP immediately, and the server can ensure whether all data transmitted to A are transmitted before disconnection, and once the transmission data is confirmed, the FIN field of the reply message is set to 1 and a random seq serial number is generated. (fin=1, ack=x+1, seq=z, z is randomly generated by the server side);
4. After receiving the TCP disconnection request of the server, the client replies the disconnection request of the server, wherein the disconnection request comprises a seq field and an ACK field which are randomly generated, and the ACK field is added with 1 on the basis of the seq of the TCP disconnection request of the server, so that verification reply of the request of the server is completed. (fin=1, ack=z+1, seq=h, h is randomly generated by the client).
The 4 hand waving processes of the TCP disconnection are finished.
The distributed message communication system based on Java and MQ provides a reliable, efficient and extensible message transmission mechanism, and has decoupling property, flexibility and high availability. The system architecture can meet the communication requirement in a distributed environment, is suitable for a large-scale system and a high concurrency scene, and brings a plurality of beneficial effects.
As shown in fig. 2, one embodiment of the present invention provides a distributed message communication method based on Java and MQ, which includes the following steps:
a. integrating the JS of the communication engine at the SDK of the communication engine at the client or the webpage version client;
b. the client is connected with the server through a domain name, and the server completes IP address resolution through domain name resolution;
c. the server side uses Nginx to carry out load balancing and distributes the load balancing to the Broker cluster at the back end;
d. The client establishes a communication channel with the server, and completes initialization connection through 3 times of handshake and 4 times of waving;
e. the client sends a subscription request, and the interested message theme is appointed;
f. the server receives the subscription request, and performs protocol analysis and establishment of long connection;
g. The server distributes according to the message theme, and sends the message to the corresponding consumer by using a consistency hash algorithm or a load balancing strategy; the server distributes and records the message through an event mechanism, wherein the message comprises a local cache, a Redis cache and a ES (Elasticsearch) cache;
h. The client sends a message to a browser cluster aiming at a subscribed topic, the browser cluster addresses a channel corresponding to the subscribed topic in the local machine and transmits the channel to a RabbitMQ, and the channel is transmitted to an application host of a Broker in the next cluster after an identifier is added, wherein if the message has a unique identifier of RabbitMq, the channel is not transmitted after the local machine consumes;
i. If the receiving end goes offline, the message remains in Redis and ES until the receiving end reconnects.
In this embodiment, the client uses an application program written in Java, and the server uses MQ to implement receiving, distributing and forwarding of the message; message passing and processing are realized through Java programming language, local buffer memory is used as first-level buffer memory, redis is used as second-level buffer memory, and elastic search is used as physical storage to realize reading and storage of messages, and RabbitMQ is used as message component to carry out broadcast-like message distribution.
In this embodiment, the distributed message communication method based on Java and MQ uses a distributed message communication system based on Java and MQ to perform the above steps, and when performing the operation, the following steps are used:
1. If the SDK of the integrated communication engine is required to be accessed to a communication engine access to a communication engine application menu of a Huiyin official website, the information of the relevant APP is filled in, then the application registration APP is submitted, whether the application passes or not and the progress can be checked in an application list, and then the appId and a key provided by relevant download addresses and authorization can be obtained after the application passes, and an integrated demo example is provided, so that a developer is helped to complete the communication engine access.
2. The client is connected with the server through the domain name, the server completes IP address resolution through the domain name resolution server and distributes the IP address resolution to Nginx, the Nginx is distributed to a Broker cluster at the back end through a load, the Broker cluster receives a request and completes initialization connection through 3 times of handshaking and 4 times of handshaking.
3. The client subscribes the message theme through the established communication channel, the server performs corresponding processing through analyzing whether the protocol of the MQTT or the protocol of the WS through the message main entrance, after the protocol analysis is completed, the long connection of the corresponding communication channel is correspondingly established, after the subsequent analysis is completed, the processing of the message is distributed through the internal event, and the local cache, the redis cache and the es cache are recorded.
4. After receiving the message sent for the topic, the browser cluster firstly addresses whether a channel subscribing the topic exists in the local machine, if yes, the message is transmitted according to the channel information, then after the message is forwarded to a RabbitMq, rabbitMq internal message flow queue to receive the message, a special identifier is attached to the application host of the Broker in other clusters, and the processing mode of the other hosts is similar to that of the first host receiving the message, except that if the message is provided with the special identifier of RabbitMq, the message is not forwarded to a RabbitMq circulation queue after being consumed, and the flow is directly ended.
5. When the receiving end is connected again, the message is sent to the client end, so that a message compensation mechanism is realized, and the loss of the non-online state message is avoided.
After receiving the request, the Broker cluster completes initialization connection through a 3-way handshake and a 4-way waving mode, wherein the 3-way handshake comprises the following steps:
First handshake: the client sends a data packet with SYN (synchroni ze) marks to the server;
The 2 nd handshake: after the server receives the data packet successfully, a data packet with a SYN/ACK mark is returned to transmit confirmation information, which indicates that the data packet is received;
3 rd handshake: the client transmits back a data packet with an ACK mark, which indicates that I know that the handshake is finished.
Wherein: SYN flag bit number 1, indicating that a TCP connection is established; the ACK flag indicates a verification field.
In this embodiment, the three-way handshake procedure is described in detail as follows:
1. The client sends a request message for establishing the TCP connection, wherein the message contains a seq serial number which is randomly generated by the sender, and the SYN field in the message is set to be 1, which indicates that the TCP connection needs to be established. (syn=1, seq=x, x is a randomly generated value);
2. the server replies a TCP connection request message sent by the client, wherein the message contains a seq sequence number which is randomly generated by the replying terminal, the SYN is set to be 1, an ACK field is generated, and the value of the ACK field is replied by adding 1 on the basis of the sequence number seq sent by the client, so that the client knows that the own TCP establishment request is verified when receiving information. (syn=1, ack=x+1, seq=y, y is a randomly generated value) ack plus 1 here can be understood as an acknowledgement and who established the connection;
3. After receiving the TCP establishment verification request sent by the server, the client will make its own sequence number add 1, and reply to the ACK verification request again, add 1 to the seq sent by the server to reply. (syn=1, ack=y+1, seq=x+1).
Since the TCP connection is full duplex, each direction must be closed separately. The principle is that after a party has completed its data transmission task, it can send an FI N to terminate the connection in this direction. Receipt of an FI N only means that there is no data flow in this direction and a TCP connection can still send data after receipt of an FI N. One party that first performs a shutdown will perform an active shutdown while the other party performs a passive shutdown.
In this embodiment, the 4 times of waving of the hand includes the following steps:
Waving hands for the 1 st time: the client sends a FIN to close the data transmission from the client to the server, and the client enters a fin_wait_1 state;
The 2 nd hand waving: after receiving the FIN, the server sends an ACK to the client to confirm that the sequence number is received sequence number +1 (same as SYN, one FIN occupies one sequence number), and the server enters a close_wait state;
3 rd hand waving: the server sends a FIN to close the data transmission from the server to the client, and the server enters a LAST_ACK state;
The 4 th hand waving: after receiving the FIN, the client t enters a time_wait state, then sends an ACK to the Server, confirms that the sequence number is the received sequence number +1, and the Server enters a CLOSED state to finish four waving operations.
In this embodiment, the process of waving the hand for 4 times is described in detail as follows:
1. The client sends a message of a TCP connection disconnection request, wherein the message contains a seq serial number which is randomly generated by the sender, and the FIN field in the message is set to 1 to indicate that the TCP connection needs to be disconnected. (fin=1, seq=x, x is randomly generated by the client);
2. The server replies a TCP disconnection request message sent by the client, wherein the TCP disconnection request message contains a seq sequence number which is randomly generated by the replying terminal, and an ACK field is generated, and the value of the ACK field is replied by adding 1 on the basis of the seq sequence number sent by the client, so that the client can know that the own TCP disconnection request is verified when receiving information. (fin=1, ack=x+1, seq=y, y is randomly generated by the server);
3. After the server replies the TCP disconnection request of the client, the server does not disconnect the TCP immediately, and the server can ensure whether all data transmitted to A are transmitted before disconnection, and once the transmission data is confirmed, the FIN field of the reply message is set to 1 and a random seq serial number is generated. (fin=1, ack=x+1, seq=z, z is randomly generated by the server side);
4. After receiving the TCP disconnection request of the server, the client replies the disconnection request of the server, wherein the disconnection request comprises a seq field and an ACK field which are randomly generated, and the ACK field is added with 1 on the basis of the seq of the TCP disconnection request of the server, so that verification reply of the request of the server is completed. (fin=1, ack=z+1, seq=h, h is randomly generated by the client).
The 4 hand waving processes of the TCP disconnection are finished.
In the distributed message communication method based on Java and MQ, the Message Queue (MQ) is used as a middleware, so that reliable transfer of the message can be ensured. The message queue has a persistence mechanism, so that the message can be safely stored even if a fault or network interruption occurs in the communication process, the message is persistence and is retransmitted after the system is recovered, the message is ensured not to be lost, and the risk of message loss is avoided.
The distributed message communication system adopts an asynchronous communication mode of a message queue, and a sender can continue other operations after sending the message to the queue without waiting for instant response of a receiver. The asynchronous communication mode improves the throughput and the performance of the system and can better process burst high concurrency requests.
Referring to fig. 1, a client (PC, terminal, APP) connects to a server host by using a load balancing cluster, each load balancing corresponds to a single node of the server host, and only can be used in a Broker application of the server host, and protocol analysis is performed through a message total entry to perform Event registration and security management, where the Event registration includes a message subscription Event, channel connecting an Event, a message occurrence Event, and a message persistent Event; after the data is read and written through the temporary storage of the message and the durable part of the message, the resource is recovered through the connection report, and the recovery is carried out through the java self-carried G1 recoverer; the storage part of the server host computer stores or temporarily stores the information through the L2 cache connection index, the L3 cache information index and the RAM memory connection relation, realizes the local storage in the memory through the persistent file-ES and stores the information of the unconnected receiver in the elastic search; messages are also passed through the Broker cluster to channels and rabkitmq subscribing to the topic.
By using the Broker cluster and load balancing technology in the invention, the system can be easily expanded to handle larger message traffic and more client connections. By adding new message queue nodes and application hosts and distributing requests to different nodes by using a load balancing technology, the system can realize lateral expansion and improve the scalability and fault tolerance of the system. The sender and the receiver are decoupled by using a message queue, and the sender only needs to send the message into the queue, and does not need to know who the specific receiver is. The decoupling property enables the system components to be evolved independently, reduces the coupling degree of the system, and improves the maintainability and expandability of the system.
The invention also saves the message of the unconnected receiver in the Redis and the elastic search, and the system can resend the message after the receiver is reconnected, thereby realizing the reservation and compensation mechanism of the message. This ensures that important messages are not lost even if the recipient is temporarily offline. By using a Broker cluster and message queues, the system achieves high availability. Even if a certain message queue node or an application host fails, the system can still continue to operate, and the transmission and processing of the message are ensured, so that reliable service is provided.
The distributed messaging system enables real-time messaging and processing by establishing long connections and using asynchronous communication modes. At the same time, the message queue allows multiple consumers to process messages concurrently, thereby improving the concurrency performance of the system. Multiple consumers can independently acquire messages from the queues for processing, so that parallel execution of tasks is realized, and the processing speed of the system is increased.
In one embodiment, a computer device is provided in an embodiment of the present invention, including at least one processor, and a memory communicatively coupled to the at least one processor, the memory storing instructions executable by the at least one processor to cause the at least one processor to perform the Java and MQ based distributed messaging method, the processor executing instructions to implement the steps in the Java and MQ based distributed messaging method.
In one embodiment of the invention, there is also provided a readable storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of the Java and MQ based distributed messaging method described above.
Those skilled in the art will appreciate that implementing all or part of the above described methods may be accomplished by way of a computer program stored on a non-transitory computer readable storage medium, which when executed may comprise the steps of the embodiments of the methods described above. Any reference to memory, storage, database, or other medium used in embodiments provided herein may include at least one of non-volatile and volatile memory.
The foregoing description of the preferred embodiments of the invention is not intended to be limiting, but rather is intended to cover all modifications, equivalents, and alternatives falling within the spirit and principles of the invention.
Claims (5)
1. The distributed message communication system based on Java and MQ is characterized by comprising a client and a server, wherein the APP of the client integrates the SDK of a communication engine, and the JS of the webpage client integrates the communication engine and is used for communication with the server; the server side comprises:
domain name resolution server: resolving the domain name into a corresponding IP address;
the nmginx server: the method comprises the steps that load balancing and request distribution are achieved, and the Nginx server is further used for distributing requests from the client to a Broker cluster at the rear end according to a preset load balancing algorithm;
The domain name resolution server, the Nginx server and the back-end Broker cluster are communicated through network connection; the domain name resolution server and the Nginx server are also used for dynamically adjusting a load balancing strategy according to the change of the system load;
The client is connected with the server through a domain name, the server is further used for carrying out IP address analysis through the domain name analysis server and distributing the IP address analysis to the Nginx server, the Nginx server distributes a request to a Broker cluster at the rear end through a load balancing algorithm, and after the Broker cluster receives the request, initialization connection is completed through 3-time handshake and 4-time waving modes;
In a distributed message communication system based on Java and MQ, a client performs message subscription with a server by establishing a communication channel, wherein the server is used for establishing corresponding long connection according to a message protocol type and processing and recording messages by an internal event distribution mechanism, wherein the processing and recording of the messages comprises a local cache, a Redis cache and an elastic search cache;
The Broker cluster is further configured to check whether a channel subscribed to a certain topic exists, if yes, first transmit a message to the channel, then forward the message to a message flow queue in RabbitMQ, rabbitMQ, and after receiving the message, forward the message to a Broker application host in the Broker cluster according to a set identifier;
The distributed message communication system based on Java and MQ also comprises a message reservation and compensation mechanism, and when a Broker cluster transmits a message to a channel, if a receiving end of RabbitMQ is not connected, a client side is used as a sender to store the message in Redis and an elastic search; after the receiving end of RabbitMQ is reconnected, a distributed message communication system based on Java and MQ retrieves stored messages in Redis and elastic search and sends the messages to the receiving end to complete a message compensation mechanism;
the message compensation mechanism comprises multiple attempts to send unsuccessful messages, records the unsuccessful messages in the personal session after the set number of attempts, and when the receiving end is reconnected, the system tries to send the recorded unsuccessful messages again to complete the compensation of the messages, wherein the message compensation mechanism compensates according to the set number of retries and the time interval.
2. The Java and MQ based distributed messaging system of claim 1, wherein the nginix server is further adapted for failure detection and failover, and wherein the nginix server is further adapted to automatically switch request forwarding to a normally operating server when a server in the backend Broker cluster fails.
3. The Java and MQ based distributed messaging system of claim 2, wherein the server converts the client request to an IP address by domain name resolution and distributes the request to the Broker cluster of the backend by a load balancer, wherein the nmginx server acts as the load balancer.
4. A Java and MQ based distributed messaging system according to claim 3, wherein messaging and processing in the Java and MQ based distributed messaging system is implemented in the Java programming language, reading and storing of messages is implemented using local caching as a primary cache, dis as a secondary cache, and elastic search as physical storage, and class broadcast type message distribution is implemented by rabitmq as a message component.
5. A distributed message communication method based on Java and MQ, wherein the distributed message communication system based on Java and MQ as set forth in claim 4 is used for communication; the distributed message communication method based on Java and MQ comprises the following steps:
Integrating the JS of the communication engine at the SDK of the communication engine at the client or the webpage version client;
the client is connected with the server through a domain name, and the server completes IP address resolution through domain name resolution;
the server side uses Nginx to carry out load balancing and distributes the load balancing to the Broker cluster at the back end;
The client establishes a communication channel with the server, and completes initialization connection through 3 times of handshake and 4 times of waving;
the client sends a subscription request, and the interested message theme is appointed;
The server receives the subscription request, and performs protocol analysis and establishment of long connection;
The server distributes according to the message theme, and sends the message to the corresponding consumer by using a consistency hash algorithm or a load balancing strategy; the server distributes and records the message through an event mechanism, wherein the message comprises a local cache, a Redis cache and an elastic search cache;
The client sends a message to a browser cluster aiming at a subscribed topic, the browser cluster addresses a channel corresponding to the subscribed topic in the local machine and transmits the channel to a RabbitMQ, and the channel is transmitted to an application host of a Broker in the next cluster after an identifier is added, wherein if the message has a unique identifier of RabbitMq, the channel is not transmitted after the local machine consumes;
If the receiving end goes offline, the message remains in Redis and elastic search until the receiving end reconnects.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311303481.9A CN117354117B (en) | 2023-10-10 | 2023-10-10 | Java and MQ-based distributed message communication method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311303481.9A CN117354117B (en) | 2023-10-10 | 2023-10-10 | Java and MQ-based distributed message communication method and system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN117354117A CN117354117A (en) | 2024-01-05 |
| CN117354117B true CN117354117B (en) | 2024-05-31 |
Family
ID=89368586
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311303481.9A Active CN117354117B (en) | 2023-10-10 | 2023-10-10 | Java and MQ-based distributed message communication method and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117354117B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN118784453B (en) * | 2024-08-16 | 2025-09-02 | 上海伊莱诺瓦储能技术有限公司 | MQTT client message assurance method and system under multiple brokers |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111565229A (en) * | 2020-04-29 | 2020-08-21 | 创盛视联数码科技（北京）有限公司 | Communication system distributed method based on Redis |
| WO2020211344A1 (en) * | 2019-04-17 | 2020-10-22 | 平安科技（深圳）有限公司 | Mqtt-based message distribution method, server, apparatus, and storage medium |
| CN113691611A (en) * | 2021-08-23 | 2021-11-23 | 湖南大学 | A distributed high-concurrency transaction processing method and system, device and storage medium for blockchain |
-
2023
- 2023-10-10 CN CN202311303481.9A patent/CN117354117B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2020211344A1 (en) * | 2019-04-17 | 2020-10-22 | 平安科技（深圳）有限公司 | Mqtt-based message distribution method, server, apparatus, and storage medium |
| CN111565229A (en) * | 2020-04-29 | 2020-08-21 | 创盛视联数码科技（北京）有限公司 | Communication system distributed method based on Redis |
| CN113691611A (en) * | 2021-08-23 | 2021-11-23 | 湖南大学 | A distributed high-concurrency transaction processing method and system, device and storage medium for blockchain |
Non-Patent Citations (2)
| Title |
|---|
| 基于Elasticsear...的商业变现平台的设计与实现;刘涛;优秀硕士学位论文;20220331;第2、4、5章 * |
| 基于Redis和RabbitMQ的GPON告警采集系统;姜秀芳;李鹏飞;胡晶;盛苗;;中国新通信;20200905(第17期);142-144 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN117354117A (en) | 2024-01-05 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8996626B2 (en) | Terminal and intermediate node in content oriented networking environment and communication method of terminal and intermediate node | |
| US20080133646A1 (en) | System and method for fully distributed network with agents | |
| US8549122B2 (en) | System and method for communication agent within a fully distributed network | |
| JP4965574B2 (en) | Port sharing among multiple processes | |
| US7554992B2 (en) | Mobile device communications system and method | |
| JP5485993B2 (en) | Service load balancing | |
| CN101370035A (en) | Method and system for dynamic client/server network management | |
| US20120166593A1 (en) | Data transmission system and method using relay server | |
| US20090019106A1 (en) | Method of redirecting client requests to web services | |
| CN106453136A (en) | Method and device for establishing message queue | |
| US20110035413A1 (en) | Diameter bus communications between processing nodes of a network element | |
| CN112181681B (en) | Remote calling method, device, computer equipment and storage medium | |
| CN117354117B (en) | Java and MQ-based distributed message communication method and system | |
| JP2012083891A (en) | Failover system, storage processor, and failover control method | |
| US7904551B2 (en) | Unicast clustering messaging | |
| EP3920035B1 (en) | Message transmission/reception method, communication device, and program | |
| CN112671554A (en) | Node fault processing method and related device | |
| CN116233243A (en) | Communication system and method in weak network environment | |
| US8156174B2 (en) | Method and system for information exchange utilizing an asynchronous persistent store protocol | |
| EP1955181B1 (en) | Method and system for registering a distributed service site | |
| JP5405550B2 (en) | File transmission management system and file transmission management method for supporting file transmission in mobile messaging service | |
| CN116962547B (en) | MQ-based dynamic data gateway communication method | |
| CN117319321A (en) | Message pushing system and message pushing method | |
| US20080147839A1 (en) | System and method for central component console within a fully distributed network | |
| CN116260859B (en) | Data configuration system |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |