CN115658339A - Method, system, device and storage medium for realizing interface message idempotency - Google Patents
Method, system, device and storage medium for realizing interface message idempotency Download PDFInfo
- Publication number
- CN115658339A CN115658339A CN202211292816.7A CN202211292816A CN115658339A CN 115658339 A CN115658339 A CN 115658339A CN 202211292816 A CN202211292816 A CN 202211292816A CN 115658339 A CN115658339 A CN 115658339A
- Authority
- CN
- China
- Prior art keywords
- state
- processing
- service request
- request
- time limit
- 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.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 53
- 238000001914 filtration Methods 0.000 claims description 6
- 238000012795 verification Methods 0.000 abstract description 7
- 230000006870 function Effects 0.000 description 10
- 238000010586 diagram Methods 0.000 description 5
- 230000009286 beneficial effect Effects 0.000 description 4
- 238000004590 computer program Methods 0.000 description 4
- 230000008569 process Effects 0.000 description 4
- 230000002159 abnormal effect Effects 0.000 description 2
- 239000000463 material Substances 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 230000001960 triggered effect Effects 0.000 description 2
- 230000004075 alteration Effects 0.000 description 1
- 230000003111 delayed effect Effects 0.000 description 1
- 238000001514 detection method Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
- 238000003672 processing method Methods 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Images
Landscapes
- Retry When Errors Occur (AREA)
Abstract
The invention discloses a method, a system, a device and a storage medium for realizing interface message idempotent, wherein the method comprises the following steps: acquiring a service request, and performing request deduplication processing within a first preset time limit based on the service request; executing target processing according to the service request to obtain a processing state; when the execution state is the existing state, after a second preset time limit, processing and checking are carried out according to the service request, and a processing result is obtained; and when the processing result is failure, returning to the step of executing target processing according to the service request to obtain the processing state until the obtained processing state is a success state or a failure state, or the obtained processing result is success. The invention ensures the idempotency of the request by carrying out the request deduplication processing on the service request, prevents the request from being lost by carrying out the secondary verification on the processing state and the processing result, can ensure the success rate of the service request processing by re-responding the service request when the processing result fails, and can be widely applied to the technical field of computers.
Description
Technical Field
The present invention relates to the field of computer technology, and more particularly, to a method, system, apparatus, and storage medium for implementing idempotent of interface messages.
Background
Idempotent requests mean that the same request, once or more, has the same effect on server data. The current mainstream request idempotent scheme is that a server side ensures that the same request can be filtered through redis, zookeeper or the atomicity of a database, so that the request idempotent is ensured. There is a trade-off for requests being either multiple or less frequent.
Although the prior art is capable of filtering the same request, there are the following problems: after the server side puts the message into the power table or caches, the server side is abnormal, and the request is considered to be failed; at this time, request retry is triggered, and since the message is already stored in the power table or the buffer, the server-side power filtering is triggered, and finally the request is lost.
Disclosure of Invention
In view of this, embodiments of the present invention provide a method, a system, an apparatus, and a storage medium for implementing interface message idempotent with high detection accuracy and low deployment cost.
In one aspect, an embodiment of the present invention provides a method for implementing idempotent of interface messages, including:
acquiring a service request, and based on the service request, performing request deduplication processing within a first preset time limit;
executing target processing according to the service request to obtain a processing state;
wherein the processing state comprises a success state, a failure state, and an existing state;
when the execution state is the existing state, after a second preset time limit, processing and checking are carried out according to the service request, and a processing result is obtained;
wherein the second preset time limit is greater than the first preset time limit;
and when the processing result is failure, returning to the step of executing target processing according to the service request to obtain the processing state until the obtained processing state is a success state or a failure state, or the obtained processing result is success.
Optionally, the method further comprises:
the service request is saved by a power table or cache.
Optionally, the performing request deduplication processing within a first preset time limit based on the service request includes:
based on the service request of the client, filtering the service request repeatedly acquired within a first preset time limit through a preset component of the server;
wherein the preset component comprises a database and a redis.
Optionally, after the step of executing the target processing according to the service request to obtain the processing state, the method further includes:
and deleting the service request in the power table or the cache when the processing state is a success state or after a first preset time limit.
Optionally, the failure status includes a first failure status, and the method further includes:
and deleting the service request in the power-equal table or the cache when the failure state is a first failure state.
Optionally, the failure status includes a second failure status, and the method further includes:
when the failure state is a second failure state, performing request retry processing based on the service request through the client;
and executing the target processing according to the request retry processing until reaching a preset retry number, obtaining a processing state of a successful state or a processing state of an existing state.
Optionally, when the execution state is an existing state, after a second preset time limit, performing processing verification according to the service request to obtain a processing result, where the processing result includes:
when the execution state is the existing state, the service request is stored through a client;
and after a second preset time limit, checking whether the target processing of the server is successfully processed or not through the service request of the client to obtain a processing result.
In a second aspect, an embodiment of the present invention provides a system for implementing idempotent of interface messages, including:
the device comprises a first module, a second module and a third module, wherein the first module is used for acquiring a service request and performing request deduplication processing within a first preset time limit based on the service request;
the second module is used for executing target processing according to the service request to obtain a processing state; wherein the processing state comprises a success state, a failure state, and an existing state;
a third module, configured to, when the execution state is an existing state, perform processing verification according to the service request after a second preset time limit, to obtain a processing result; wherein the second preset time limit is greater than the first preset time limit;
and the fourth module is used for returning to the step of executing target processing according to the service request to obtain the processing state when the processing result is failure until the obtained processing state is a success state or a failure state, or the obtained processing result is success.
On the other hand, the embodiment of the invention provides a device for realizing idempotent of interface messages, which comprises a processor and a memory, wherein the processor is used for processing the interface messages;
the memory is used for storing programs;
the processor executes the program to implement the method as described above.
In another aspect, an embodiment of the present invention provides a computer-readable storage medium, which stores a program, and the program is executed by a processor to implement the method as described above.
The embodiment of the invention also discloses a computer program product or a computer program, which comprises computer instructions, and the computer instructions are stored in a computer readable storage medium. The computer instructions may be read by a processor of a computer device from a computer-readable storage medium, and the computer instructions executed by the processor cause the computer device to perform the foregoing method.
The embodiment of the invention firstly obtains a service request, and based on the service request, request duplicate removal processing is carried out within a first preset time limit; executing target processing according to the service request to obtain a processing state; wherein the processing state comprises a success state, a failure state, and an existing state; when the execution state is the existing state, after a second preset time limit, processing and checking are carried out according to the service request, and a processing result is obtained; wherein the second preset time limit is greater than the first preset time limit; and when the processing result is failure, returning to the step of executing target processing according to the service request to obtain the processing state until the processing state is a success state or a failure state, or the processing result is successful. The invention ensures the ideality of the request through the request deduplication processing of the service request, prevents the request from losing through the secondary verification of the processing state and the processing result, and can ensure the success rate of the service request processing by responding to the service request again to execute the target processing when the processing result of the target processing corresponding to the service request fails based on the secondary verification.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings required to be used in the description of the embodiments are briefly introduced below, and it is obvious that the drawings in the description below are only some embodiments of the present application, and it is obvious for those skilled in the art to obtain other drawings without creative efforts.
Fig. 1 is a schematic flowchart of the overall steps of a method for implementing idempotent of interface messages according to an embodiment of the present invention;
fig. 2 is a schematic implementation flow diagram of a method for implementing idempotent of interface messages according to an embodiment of the present invention;
fig. 3 is a schematic diagram of a retry procedure after a failure status is returned according to an embodiment of the present invention;
fig. 4 is a schematic diagram of a system for implementing idempotent of interface messages according to an embodiment of the present invention;
fig. 5 is a schematic diagram of an apparatus for implementing idempotent of interface messages according to an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present application more apparent, the present application is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the present application and are not intended to limit the present application.
In view of the problems in the prior art, in one aspect, the present invention provides a method for implementing idempotent of interface messages, as shown in fig. 1, the method includes the following steps:
s100, acquiring a service request, and based on the service request, performing request deduplication processing within a first preset time limit;
it should be noted that, in some embodiments, the method further includes: storing the service request through a power equal table or a cache; based on the service request, the request deduplication processing is carried out within a first preset time limit, and the request deduplication processing method comprises the following steps: based on a service request of a client, filtering the service request repeatedly acquired within a first preset time limit through a preset component of a server; the preset component comprises a database and a redis.
Specifically, the server side can ensure that the same request can be filtered through the atomicity of the redis or the database, so that the idempotency of the request is ensured; and the server side removes the duplicate according to the request, the duplicate removing mode can use a database, redis or other middleware, the request duplicate removing time is set to be X minutes, and the same request exists in the X minutes, and then the filtering is carried out.
S200, executing target processing according to the service request to obtain a processing state;
it should be noted that the processing status includes a success status, a failure status, and an existing status; the success state represents that the service request of the service end to the client successfully executes related target processing; the failure state indicates that the server side does not execute relevant target processing on the service request of the client side; while the existing state indicates that the service request has been saved at the server (e.g., via a power table or cache), the server may have been successfully processed or may simply have recorded the request but not successfully processed based on the processing state of the target process of the service request being an ambiguous state.
In some embodiments, when the processing status is a success status or after a first predetermined time limit, the service request in the power table or the cache is deleted. It should be noted that the failure status is divided into a non-retriable failure status (i.e., a first failure status) and a retriable failure status (i.e., a second failure status). In other embodiments, when the failure state is the first failure state, the service request in the power table or the cache is deleted; further comprising: when the failure state is a second failure state, performing request retry processing based on the service request through the client; and executing the target processing according to the request retry processing until reaching a preset retry number, obtaining the processing state of a successful state or the processing state of an existing state.
S300, when the execution state is the existing state, after a second preset time limit, processing and checking are carried out according to the service request, and a processing result is obtained;
it should be noted that the second preset time limit is greater than the first preset time limit; when the execution state is the existing state, the service request is stored through the client; and after the second preset time limit, checking whether the target processing of the server is successful or not through the service request of the client, and obtaining a processing result.
S400, when the processing result is failure, returning to the step of executing target processing according to the service request to obtain the processing state until the processing state is a success state or a failure state, or the processing result is success.
The following describes in detail the implementation principle of implementing idempotent of interface messages, as shown in fig. 2, the technical solution of the present invention is implemented based on the combination of a server and a client, and the following is an explanation but not a limitation of the technical solution of the present invention:
and (3) processing by the server side:
step 1: the server removes the duplicate according to the request, and the duplicate removing mode can use a database, redis or other middleware.
Step 2: the request deduplication time is set to X minutes, indicating that there are identical requests in those X minutes, and then filtered.
And step 3: and the server processes the request, and returns a processing state to the client after the processing is finished.
The client processes in 3 cases:
case 1: the server returns a success status, and the client can directly process according to success.
Case 2: the server returns a failure status. The failure states may be divided into a retriable failure state and a non-retriable failure state. The retry is performed by the client in the retriable failure state. The retry is not stopped until the number of client retries is exceeded, the server returns a success, or the server returns an existing status.
Specifically, as shown in fig. 3, the retry procedure after returning to the failure state is as follows:
1. the client sends a request, and the server returns a failure state;
2. the client determines whether a retry condition is met. If not, directly ending the flow;
3. if the retry condition is met, 1 through 2 are repeated.
Case 3: the server returns the existing state. This state is an ambiguous state and the server may have processed successfully or may simply have recorded the request but not processed successfully. For this case, a secondary check is required. After receiving the state, the client saves the request, and after waiting for Y minutes (Y > X), the request is used for checking whether the server is successfully processed. If the verification result is unsuccessful, the client resends the request.
The present invention will be further described with reference to specific examples for the purpose of more clearly illustrating the objects and contents of the present invention, but the embodiments of the present invention are not limited thereto.
Take the short message issuing interface as an example, the msgId is used as the unique identifier for the short message
Example 1:
1) The client sends a short message to the server
2) The service end records the msgId into the redis, and then forwards the short message to an operator
3) The server side is successfully processed, the successful result is returned to the client side, and the request is completed
Example 2:
1) The client sends a short message to the server
2) The short message is not sent to the service end, and network abnormity occurs
3) The network exception is an exception requiring retry, the client needs retry, the maximum retry number is 3, and the retry interval is 3 seconds each time
4) After retrying for 1 time, the network recovers at this time, the short message is successfully issued to the service end, and the service end successfully forwards the short message to the operator. And returning a success result to the client side, and completing the request.
Example 3:
1) The client sends a short message to the server
2) The service side records the msgId into the redis, and the expiration time of the msgId is set to be 1 minute. Then a network anomaly suddenly occurs.
3) The network exception is the exception needing retry, the client needs retry, and the short message reaches the server
4) At this time, msgId is recorded in redis, the server judges that the short message has been sent, and returns the existing state to the client
5) The existing state is an ambiguous state. The client records the msgId, waits for 3 minutes, and checks whether the msgId has been successfully sent to the operator
6) If successfully sent to the carrier, the client can delete the msgId
7) If the short message is not successfully sent to the operator, the client retransmits the short message. Since the saving time of the service msgId is already exceeded, this short message can be successfully forwarded to the operator.
8) And if the processing of the step 7 fails, repeating the steps 1) to 7) continuously to retry. Until the short message is successfully issued.
On the other hand, referring to fig. 4, an embodiment of the present invention provides a system 500 for implementing idempotent of interface messages, including a first module 510, a second module 520, a third module 530, and a fourth module 540; a first module 510, configured to obtain a service request, and perform request deduplication processing within a first preset time limit based on the service request; a second module 520, configured to execute target processing according to the service request, so as to obtain a processing state; wherein the processing state comprises a success state, a failure state and an existing state; a third module 530, configured to, when the execution state is an existing state, perform processing verification according to the service request after a second preset time limit, to obtain a processing result; wherein the second preset time limit is greater than the first preset time limit; a fourth module 540, configured to, when the processing result is a failure, return to the step of executing the target processing according to the service request to obtain the processing state until the obtained processing state is a success state or a failure state, or the obtained processing result is a success.
The content of the embodiment of the method of the invention is all applicable to the embodiment of the system, the function of the embodiment of the system is the same as the embodiment of the method, and the beneficial effect achieved by the embodiment of the system is the same as the beneficial effect achieved by the method.
Referring to fig. 5, another aspect of the present invention further provides an apparatus 600 for implementing idempotent interface messages, including a processor 610 and a memory 620; the memory 610 is used for storing programs; the processor 620 executes a program to implement the method as previously described.
The content of the method embodiment of the present invention is applicable to the apparatus embodiment, the functions specifically implemented by the apparatus embodiment are the same as those of the method embodiment, and the beneficial effects achieved by the apparatus embodiment are also the same as those achieved by the method.
Yet another aspect of the embodiments of the present invention provides a computer-readable storage medium, which stores a program, which is executed by a processor to implement the method as described above.
The contents of the method embodiment of the present invention are all applicable to the computer-readable storage medium embodiment, the functions specifically implemented by the computer-readable storage medium embodiment are the same as those of the method embodiment, and the beneficial effects achieved by the method are also the same as those achieved by the method.
The embodiment of the invention also discloses a computer program product or a computer program, which comprises computer instructions, and the computer instructions are stored in a computer readable storage medium. The computer instructions may be read by a processor of a computer device from a computer-readable storage medium, and the computer instructions executed by the processor cause the computer device to perform the foregoing method.
In summary, the invention combines the server and the client to realize idempotency, the client performs retry, and the server performs idempotency; and for the uncertain state, the client performs delayed secondary check. The interface realized by the technical scheme of the invention can well ensure the idempotent of the request and ensure that the request is not lost in the case of an abnormal scene.
In alternative embodiments, the functions/acts noted in the block diagrams may occur out of the order noted in the operational illustrations. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality/acts involved. Furthermore, the embodiments presented and described in the flow charts of the present invention are provided by way of example in order to provide a more thorough understanding of the technology. The disclosed methods are not limited to the operations and logic flows presented herein. Alternative embodiments are contemplated in which the order of various operations is changed and in which sub-operations described as part of larger operations are performed independently.
Furthermore, although the present invention is described in the context of functional modules, it should be understood that, unless otherwise indicated to the contrary, one or more of the described functions and/or features may be integrated in a single physical device and/or software module, or one or more functions and/or features may be implemented in separate physical devices or software modules. It will also be appreciated that a detailed discussion of the actual implementation of each module is not necessary for an understanding of the present invention. Rather, the actual implementation of the various functional modules in the apparatus disclosed herein will be understood within the ordinary skill of an engineer, given the nature, function, and internal relationship of the modules. Accordingly, those skilled in the art can, using ordinary skill, practice the invention as set forth in the claims without undue experimentation. It is also to be understood that the specific concepts disclosed are merely illustrative of and not intended to limit the scope of the invention, which is to be determined from the appended claims along with their full scope of equivalents.
The functions may be stored in a computer-readable storage medium if they are implemented in the form of software functional units and sold or used as separate products. Based on such understanding, the technical solution of the present invention may be embodied in the form of a software product, which is stored in a storage medium and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the method according to the embodiments of the present invention. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk, or an optical disk, and various media capable of storing program codes.
The logic and/or steps represented in the flowcharts or otherwise described herein, e.g., an ordered listing of executable instructions that can be considered to implement logical functions, can be embodied in any computer-readable medium for use by or in connection with an instruction execution system, apparatus, or device, such as a computer-based system, processor-containing system, or other system that can fetch the instructions from the instruction execution system, apparatus, or device and execute the instructions. For the purposes of this description, a "computer-readable medium" can be any means that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.
More specific examples (a non-exhaustive list) of the computer-readable medium would include the following: an electrical connection (electronic device) having one or more wires, a portable computer diskette (magnetic device), a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber device, and a portable compact disc read-only memory (CDROM). Additionally, the computer-readable medium could even be paper or another suitable medium upon which the program is printed, as the program can be electronically captured, via for instance optical scanning of the paper or other medium, then compiled, interpreted or otherwise processed in a suitable manner if necessary, and then stored in a computer memory.
It should be understood that portions of the present invention may be implemented in hardware, software, firmware, or a combination thereof. In the above embodiments, the various steps or methods may be implemented in software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware, as in another embodiment, any one or combination of the following techniques, which are known in the art, may be used: a discrete logic circuit having a logic gate circuit for implementing a logic function on a data signal, an application specific integrated circuit having an appropriate combinational logic gate circuit, a Programmable Gate Array (PGA), a Field Programmable Gate Array (FPGA), or the like.
In the description herein, references to the description of the term "one embodiment," "some embodiments," "an example," "a specific example," or "some examples," etc., mean that a particular feature, structure, material, or characteristic described in connection with the embodiment or example is included in at least one embodiment or example of the invention. In this specification, the schematic representations of the terms used above do not necessarily refer to the same embodiment or example. Furthermore, the particular features, structures, materials, or characteristics described may be combined in any suitable manner in any one or more embodiments or examples.
While embodiments of the invention have been shown and described, it will be understood by those of ordinary skill in the art that: various changes, modifications, substitutions and alterations can be made to the embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the claims and their equivalents.
While the preferred embodiments of the present invention have been illustrated and described, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention as defined by the appended claims.
Claims (10)
1. A method for implementing idempotent of interface messages, comprising:
acquiring a service request, and based on the service request, performing request deduplication processing within a first preset time limit;
executing target processing according to the service request to obtain a processing state;
wherein the processing state comprises a success state, a failure state, and an existing state;
when the execution state is the existing state, after a second preset time limit, processing and checking are carried out according to the service request, and a processing result is obtained;
wherein the second preset time limit is greater than the first preset time limit;
and when the processing result is failure, returning to the step of executing target processing according to the service request to obtain the processing state until the processing state is a success state or a failure state, or the processing result is successful.
2. The method of claim 1, further comprising:
the service request is saved by a power table or cache.
3. The method of claim 1, wherein performing request deduplication processing within a first preset time limit based on the service request comprises:
based on the service request of the client, filtering the service request repeatedly acquired within a first preset time limit through a preset component of the server;
wherein the preset component comprises a database and a redis.
4. The method of claim 2, further comprising:
and deleting the service request in the power table or the cache when the processing state is a success state or after a first preset time limit.
5. The method of claim 2, wherein the failure state comprises a first failure state, the method further comprising:
and deleting the service request in the power table or the cache when the failure state is a first failure state.
6. The method of claim 1, wherein the failure state comprises a second failure state, the method further comprising:
when the failure state is a second failure state, performing request retry processing based on the service request through the client;
and executing the target processing according to the request retry processing until reaching a preset retry number, obtaining a processing state of a successful state or a processing state of an existing state.
7. The method as claimed in claim 1, wherein the performing a processing check according to the service request after a second predetermined time limit when the execution status is an existing status to obtain a processing result comprises:
when the execution state is the existing state, the service request is stored through a client;
and after a second preset time limit, checking whether the target processing of the server is successfully processed or not through the service request of the client to obtain a processing result.
8. A system for implementing idempotent interface messages, comprising:
the first module is used for acquiring a service request and performing request deduplication processing within a first preset time limit based on the service request;
the second module is used for executing target processing according to the service request to obtain a processing state; wherein the processing state comprises a success state, a failure state, and an existing state;
the third module is used for processing and checking according to the service request after a second preset time limit when the execution state is the existing state to obtain a processing result; wherein the second preset time limit is greater than the first preset time limit;
and the fourth module is used for returning to the step of executing target processing according to the service request to obtain the processing state when the processing result is failure until the obtained processing state is a success state or a failure state, or the obtained processing result is success.
9. An apparatus for implementing idempotent of interface messages, comprising a processor and a memory;
the memory is used for storing programs;
the processor executing the program realizes the method of any one of claims 1 to 7.
10. A computer-readable storage medium, characterized in that the storage medium stores a program, which is executed by a processor to implement the method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211292816.7A CN115658339B (en) | 2022-10-21 | 2022-10-21 | Method, system, device and storage medium for realizing idempotent of interface message |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211292816.7A CN115658339B (en) | 2022-10-21 | 2022-10-21 | Method, system, device and storage medium for realizing idempotent of interface message |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN115658339A true CN115658339A (en) | 2023-01-31 |
| CN115658339B CN115658339B (en) | 2023-11-14 |
Family
ID=84989801
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211292816.7A Active CN115658339B (en) | 2022-10-21 | 2022-10-21 | Method, system, device and storage medium for realizing idempotent of interface message |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115658339B (en) |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7840674B1 (en) * | 2004-05-10 | 2010-11-23 | Intuit Inc. | Routing messages across a network in a manner that ensures that non-idempotent requests are processed |
| WO2021217986A1 (en) * | 2020-04-30 | 2021-11-04 | 平安科技（深圳）有限公司 | Distributed message transmission method and apparatus, computer device and storage medium |
| CN113900842A (en) * | 2021-12-10 | 2022-01-07 | 飞狐信息技术（天津）有限公司 | Message consumption method and device, electronic equipment and computer storage medium |
| CN115168341A (en) * | 2022-06-17 | 2022-10-11 | 北京结慧科技有限公司 | Service processing method, system, medium and equipment |
-
2022
- 2022-10-21 CN CN202211292816.7A patent/CN115658339B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7840674B1 (en) * | 2004-05-10 | 2010-11-23 | Intuit Inc. | Routing messages across a network in a manner that ensures that non-idempotent requests are processed |
| WO2021217986A1 (en) * | 2020-04-30 | 2021-11-04 | 平安科技（深圳）有限公司 | Distributed message transmission method and apparatus, computer device and storage medium |
| CN113900842A (en) * | 2021-12-10 | 2022-01-07 | 飞狐信息技术（天津）有限公司 | Message consumption method and device, electronic equipment and computer storage medium |
| CN115168341A (en) * | 2022-06-17 | 2022-10-11 | 北京结慧科技有限公司 | Service processing method, system, medium and equipment |
Non-Patent Citations (1)
| Title |
|---|
| 杨成荣等: "基于微服务架构的数据一致性方法研究", 《电脑知识与技术》, vol. 16, no. 8, pages 266 - 268 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN115658339B (en) | 2023-11-14 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109558400B (en) | Data processing method, device, equipment and storage medium | |
| CN110968586B (en) | Distributed transaction processing method and device | |
| CN111813791A (en) | Method and equipment for distributed transaction compensation | |
| CN111273870B (en) | Method, equipment and storage medium for iterative migration of mass data among cloud storage systems | |
| CN105471714A (en) | Message processing method and device | |
| US20170123926A1 (en) | Ensuring crash-safe forward progress of a system configuration update | |
| CN114385674A (en) | Platform message tracking method, system, device and storage medium | |
| CN114281798A (en) | Data migration method and device for heterogeneous database and computer readable medium | |
| CN110737716A (en) | data writing method and device | |
| US20200409683A1 (en) | Updating method, terminal and electronic device | |
| CN115658339A (en) | Method, system, device and storage medium for realizing interface message idempotency | |
| CN113886264A (en) | Embedded method, device, equipment and storage medium of distributed database | |
| CN111741080B (en) | Network file distribution method and device | |
| CN105653695A (en) | Concurrent data request processing method and device | |
| CN106528876B (en) | The information processing method and distributed information processing system of distributed system | |
| CN107908370B (en) | Data storage method and device | |
| CN103049351B (en) | The log processing method of multivariate data server and device | |
| CN105760283A (en) | Log output method and device | |
| CN115268778A (en) | Data acquisition method and device and electronic equipment | |
| CN115145905A (en) | Data processing method, system, electronic equipment and readable storage medium | |
| CN111371818B (en) | Data request verification method, device and equipment | |
| CN114077595A (en) | Log backup cleaning method and device for Web middleware type container | |
| CN109918231B (en) | Data reforming abnormity repairing method, device, equipment and storage medium | |
| US20090327654A1 (en) | Method of Handling Duplicate or Invalid Node Controller IDs in a Distributed Service Processor Environment | |
| CN117454905B (en) | Disposable semantic method, device, equipment and readable storage medium |
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 |