CN115658339B - Method, system, device and storage medium for realizing idempotent of interface message - Google Patents
Method, system, device and storage medium for realizing idempotent of interface message Download PDFInfo
- Publication number
- CN115658339B CN115658339B CN202211292816.7A CN202211292816A CN115658339B CN 115658339 B CN115658339 B CN 115658339B CN 202211292816 A CN202211292816 A CN 202211292816A CN 115658339 B CN115658339 B CN 115658339B
- Authority
- CN
- China
- Prior art keywords
- processing
- state
- service request
- request
- failure
- 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
- 238000000034 method Methods 0.000 title claims abstract description 50
- 238000012795 verification Methods 0.000 claims abstract description 11
- 238000001914 filtration Methods 0.000 claims description 5
- 230000006870 function Effects 0.000 description 10
- 230000005856 abnormality Effects 0.000 description 5
- 238000010586 diagram Methods 0.000 description 5
- 238000004590 computer program Methods 0.000 description 4
- 230000009286 beneficial effect Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 238000006467 substitution reaction Methods 0.000 description 3
- 230000002159 abnormal effect Effects 0.000 description 2
- 238000003491 array Methods 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
- 230000003111 delayed effect Effects 0.000 description 1
- 238000001514 detection method Methods 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
Landscapes
- Retry When Errors Occur (AREA)
Abstract
The application discloses a method, a system, a device and a storage medium for realizing idempotent of interface messages, wherein the method comprises the following steps: acquiring a service request, and performing request deduplication processing in a first preset period 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 period, performing processing verification according to the service request to obtain a processing result; and when the processing result is failure, returning to the step of executing the 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 application ensures the request idempotency through the request de-duplication processing of the service request, prevents the request from being lost 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 the service request again when the processing result fails.
Description
Technical Field
The application relates to the technical field of computers, in particular to a method, a system, a device and a storage medium for realizing idempotent of interface messages.
Background
Request idempotent refers to the fact that the same request is requested one or more times, and the influence on the server data is the same. The current mainstream request idempotent schemes ensure that the same requests can be filtered through redis, zookeeper or the atomicity of a database, so that request idempotent is ensured. There is a multiple or rare trade-off for requests.
Although the prior art is able to filter the same requests, there are the following problems: after the server side puts the message into an idempotent table or caches, the server side is abnormal, and the request is considered as failure; at this time, request retry is triggered, and the server-side idempotent filtering is triggered because the message is already stored in the idempotent table or cached, so that the request is lost finally.
Disclosure of Invention
In view of the above, the embodiment of the application provides a method, a system, a device and a storage medium for realizing idempotent of interface messages, which have high detection precision and low deployment cost.
In one aspect, an embodiment of the present application provides a method for implementing idempotent of interface messages, including:
acquiring a service request, and performing request deduplication processing in a first preset period based on the service request;
executing target processing according to the service request to obtain a processing state;
wherein the processing states include a success state, a failure state, and an existing state;
when the processing state is the existing state, after a second preset period, processing and checking are carried out according to the service request, and a processing result is obtained;
wherein the second preset period is greater than the first preset period;
and when the processing result is failure, returning to the step of executing target processing according to the service request to obtain a processing state until the processing state is a successful state or a failure state or the processing result is successful.
Optionally, the method further comprises:
the service request is saved by an idempotent table or cache.
Optionally, the performing request deduplication processing in a first preset period based on the service request includes:
filtering the service request repeatedly acquired within a first preset period through a preset component of a server based on the service request of the client;
wherein the preset component comprises a database and redis.
Optionally, after the step of executing the target process according to the service request to obtain the processing state, the method further includes:
and deleting the idempotent table or the service request in the cache when the processing state is a successful state or after a first preset period.
Optionally, the failure state includes a first failure state, and the method further includes:
and deleting the service request in the idempotent table or the cache when the failure state is the first failure state.
Optionally, the failure state includes a second failure state, and the method further includes:
when the failure state is the 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 the preset retry times are reached, the processing state of a successful state or the processing state of an existing state is obtained.
Optionally, when the processing state is an existing state, after a second preset period, processing verification is performed according to the service request, so as to obtain a processing result, including:
when the processing state is the existing state, the service request is saved through the client;
and after a second preset period, checking whether the target processing of the server side is successful or not through the service request of the client side, and obtaining a processing result.
In a second aspect, an embodiment of the present application provides a system for implementing idempotent of interface messages, including:
the first module is used for acquiring a service request, and carrying out request deduplication processing in a first preset period 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 states include a success state, a failure state, and an existing state;
the third module is used for performing processing verification according to the service request after a second preset period to obtain a processing result when the processing state is the existing state; wherein the second preset period is greater than the first preset period;
and the fourth module is used for returning to the step of executing the target processing according to the service request to obtain the processing state until the processing state is a successful state or a failure state or the processing result is successful when the processing result is failure.
On the other hand, the embodiment of the application provides a device for realizing idempotent of interface messages, which comprises a processor and a memory;
the memory is used for storing programs;
the processor executes the program to implement the method as described above.
In another aspect, embodiments of the present application provide a computer-readable storage medium storing a program that is executed by a processor to implement a method as described above.
Embodiments of the present application also disclose a computer program product or computer program comprising computer instructions stored in a computer readable storage medium. The computer instructions may be read from a computer-readable storage medium by a processor of a computer device, and executed by the processor, to cause the computer device to perform the foregoing method.
The embodiment of the application firstly obtains a service request, and based on the service request, requests for duplication removal processing are carried out within a first preset period; executing target processing according to the service request to obtain a processing state; wherein the processing states include a success state, a failure state, and an existing state; when the processing state is the existing state, after a second preset period, processing and checking are carried out according to the service request, and a processing result is obtained; wherein the second preset period is greater than the first preset period; and when the processing result is failure, returning to the step of executing target processing according to the service request to obtain a processing state until the processing state is a successful state or a failure state or the processing result is successful. The application ensures the request idempotency through the request de-duplication processing of the service request, prevents the request from being lost 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 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 of the embodiments of the present application, the drawings required for the description of the embodiments will be briefly described below, and it is apparent that the drawings in the following description are only some embodiments of the present application, and other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a flowchart illustrating the overall steps of a method for implementing idempotent interface messages according to an embodiment of the present application;
FIG. 2 is a schematic diagram of an implementation flow of a method for implementing idempotent interface messages according to an embodiment of the present application;
FIG. 3 is a schematic diagram of a retry flow after returning to a failed state according to an embodiment of the present application;
FIG. 4 is a schematic diagram of a system for implementing idempotent interface messages according to an embodiment of the present application;
fig. 5 is a schematic diagram of an apparatus for implementing idempotent interface messages according to an embodiment of the present application.
Detailed Description
The present application 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 application 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 application.
In order to solve the problems in the prior art, in one aspect, the present application 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 performing request deduplication processing in a first preset period based on the service request;
it should be noted that, in some embodiments, the method further includes: storing the service request through an idempotent table or a cache; based on the service request, performing request deduplication processing within a first preset period, including: based on the service request of the client, filtering the service request repeatedly acquired within a first preset period through a preset component of the server; the preset component comprises a database and redis.
Specifically, the server side ensures that the same request can be filtered through the atomicity of redis or a database, so that the request idempotency is ensured; and the server side can use a database, redis or other middleware according to the request for deduplication, the request deduplication time is set to be X minutes, the same request is found in the X minutes, and the filtering is performed.
S200, executing target processing according to the service request to obtain a processing state;
it should be noted that the processing states include a success state, a failure state, and an existing state; the success state indicates that the service end successfully executes related target processing for the service request of the client; the failure state indicates that the service end does not execute relevant target processing for the service request of the client; while the presence state indicates that the service request has been saved at the server (e.g., by an idempotent 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 processing of the service request being an ambiguous state.
In some embodiments, when the processing state is a successful state, or after a first preset period, the service request in the idempotent table or cache is deleted. It should be further noted that the failed state is classified into a failed state that is not retriable (i.e., a first failed state) and a failed state that is retriable (i.e., a second failed state). In other embodiments, when the failure state is the first failure state, the service request in the idempotent table or cache is deleted; further comprises: when the failure state is the second failure state, carrying out request retry processing based on the service request by the client; and executing target processing according to the request retry processing until the preset retry times are reached, and obtaining the processing state of the successful state or the processing state of the existing state.
S300, when the processing state is the existing state, after a second preset period, 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 period is greater than the first preset period; when the processing state is the existing state, storing the service request through the client; and after the second preset period, checking whether the target processing of the server is successful or not through the service request of the client to obtain a processing result.
And S400, when the processing result is failure, returning to the step of executing the target processing according to the service request to obtain the processing state until the processing state is a successful state or a failure state or the processing result is successful.
The following describes in detail the implementation principle of implementing idempotent of interface messages according to the present application, as shown in fig. 2, the technical solution of the present application is implemented based on the combination of a server and a client, and the following is an explanation of the technical solution of the present application, not a limitation:
and (3) processing at a server:
step 1: the server side can use a database, redis or other middleware according to the request for deduplication.
Step 2: the request deduplication time is set to X minutes, meaning that the same request is again within this X minutes, and then filtered.
Step 3: the server processes the request and returns a processing state to the client after the processing is completed.
The client processes according to 3 cases:
case 1: the server returns a success state, and the client can directly process according to success.
Case 2: and the server returns a failure state. The failure state may be classified into a retriable failure state and a non-retriable failure state. And (3) retrying the failed state, and then retrying by the client. And stopping retry until the number of times of the retry of the client, the success of the return of the server or the return of the server to the existing state is exceeded.
Specifically, as shown in fig. 3, the retry flow 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 judges whether the retry condition is met. If the flow does not accord with the direct ending flow;
3. if the retry condition is met, 1 to 2 are repeated.
Case 3: the server returns to the existing state. This state is an ambiguous state, and the server may have successfully processed or may simply have recorded the request, but not successfully processed. For this case, a secondary check is required. After receiving this state, the client saves the request, waits for Y minutes (Y > X), and verifies with the request whether the server has succeeded in processing. If the verification is unsuccessful, the client resends the request.
For the purpose of illustrating the application more clearly, the application is further described below with reference to specific examples, but the embodiments of the application are not limited thereto.
Taking a short message issuing interface as an example, the short message service msgId is taken as a unique identifier
Example 1:
1) The client sends a short message to the server
2) The service end records the msgId to redis and then forwards the short message to the operator
3) The server processes successfully, returns the successful result to the client, and requests to complete
Example 2:
1) The client sends a short message to the server
2) Short message does not reach server side yet, network abnormality occurs
3) The network abnormality is an abnormality requiring retry, the client needs to retry, the maximum retry number is 3, and each retry is 3 seconds
4) After retrying for 1 time, the network is recovered, the short message is successfully sent to the server, and the server successfully forwards the short message to the operator. And returning a successful result to the client, and completing the request.
Example 3:
1) The client sends a short message to the server
2) The service side records the msgId into redis, and the expiration time of the msgId is set to 1 minute. Then a network anomaly occurs suddenly.
3) The network abnormality is an abnormality requiring retry, the client needs to retry, and the short message reaches the server
4) At this time, the msgId is recorded in redis, and the server determines that the sms has been sent, and returns the existing state to the client
5) The existing state is an ambiguous state. The client records the msgId and after waiting 3 minutes, checks if the msgId has been successfully sent to the operator
6) If successfully sent to the operator, the client can delete the msgId
7) If the message is not successfully sent to the operator, the client retransmits the message. Since the save time of the service end msgId is exceeded, the short message can be successfully forwarded to the operator.
8) And (3) in the scene of high requirements on the success rate of sending the short message, if the 7 th step of processing fails, the steps 1) to 7) can be continuously repeated for retry. Until the short message is successfully issued.
On the other hand, referring to fig. 4, an embodiment of the present application 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 a request deduplication process within a first preset period based on the service request; a second module 520, configured to execute target processing according to the service request, to obtain a processing state; wherein the processing state includes a success state, a failure state, and an existing state; a third module 530, configured to perform a processing check according to the service request after the second preset period when the processing state is the existing state, to obtain a processing result; wherein the second preset period is greater than the first preset period; and a fourth module 540, configured to return to the step of executing the target process according to the service request when the processing result is failure, and obtaining the processing state until the processing state is obtained as a success state or a failure state, or the processing result is obtained as success.
The content of the method embodiment of the application is suitable for the system embodiment, the specific function of the system embodiment is the same as that of the method embodiment, and the achieved beneficial effects are the same as those of the method.
Referring to fig. 5, another aspect of an embodiment of the present application further provides an apparatus 600 for implementing idempotent of interface messages, including a processor 610 and a memory 620; the memory 610 is used for storing programs; processor 620 executes a program to implement the method as described previously.
The content of the method embodiment of the application is suitable for the device embodiment, the specific function of the device embodiment is the same as that of the method embodiment, and the achieved beneficial effects are the same as those of the method.
Another aspect of the embodiments of the present application also provides a computer-readable storage medium storing a program that is executed by a processor to implement a method as described above.
The content of the method embodiment of the application is applicable to the computer readable storage medium embodiment, the functions of the computer readable storage medium embodiment are the same as those of the method embodiment, and the achieved beneficial effects are the same as those of the method.
Embodiments of the present application also disclose a computer program product or computer program comprising computer instructions stored in a computer readable storage medium. The computer instructions may be read from a computer-readable storage medium by a processor of a computer device, and executed by the processor, to cause the computer device to perform the foregoing method.
In summary, the idempotent is realized by combining the server and the client, the client retries, and the server performs idempotent; for the uncertain state, the client performs delayed secondary verification. The interface realized by the technical scheme of the application faces to abnormal scenes, and can well ensure the request idempotency and ensure that the request is not lost.
In some 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 flowcharts of the present application 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 a larger operation are performed independently.
Furthermore, while the application is described in the context of functional modules, it should be appreciated that, unless otherwise indicated, 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 to an understanding of the present application. Rather, the actual implementation of the various functional modules in the apparatus disclosed herein will be apparent to those skilled in the art from consideration of their attributes, functions and internal relationships. Accordingly, one of ordinary skill in the art can implement the application as set forth in the claims without undue experimentation. It is also to be understood that the specific concepts disclosed are merely illustrative and are not intended to be limiting upon the scope of the application, which is to be defined in the appended claims and their full scope of equivalents.
The functions, if implemented in the form of software functional units and sold or used as a stand-alone product, may be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application may be embodied essentially or in a part contributing to the prior art or in a part of the technical solution, in the form of a software product stored in a storage medium, comprising several instructions for causing a computer device (which may be a personal computer, a server, a network device, etc.) to perform all or part of the steps of the method according to the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), a magnetic disk, or an optical disk, or other various media capable of storing program codes.
Logic and/or steps represented in the flowcharts or otherwise described herein, e.g., a ordered listing of executable instructions for implementing 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). In addition, the computer readable medium may even be paper or other suitable medium on which the program is printed, as the program may 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 is to be understood that portions of the present application may be implemented in hardware, software, firmware, or a combination thereof. In the above-described embodiments, the various steps or methods may be implemented in software or firmware stored in a memory and executed by a suitable instruction execution system. For example, if implemented in hardware, as in another embodiment, may be implemented using any one or combination of the following techniques, as is well known in the art: discrete logic circuits having logic gates for implementing logic functions on data signals, application specific integrated circuits having suitable combinational logic gates, programmable Gate Arrays (PGAs), field Programmable Gate Arrays (FPGAs), and the like.
In the description of the present specification, a description referring to terms "one embodiment," "some embodiments," "examples," "specific examples," or "some examples," etc., means 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 present application. In this specification, schematic representations of the above terms do not necessarily refer to the same embodiments or examples. 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 present application have been shown and described, it will be understood by those of ordinary skill in the art that: many changes, modifications, substitutions and variations may be made to the embodiments without departing from the spirit and principles of the application, the scope of which is defined by the claims and their equivalents.
While the preferred embodiment of the present application has been described in detail, the present application is not limited to the embodiments described above, and those skilled in the art can make various equivalent modifications or substitutions without departing from the spirit of the present application, and these equivalent modifications or substitutions are included in the scope of the present application as defined in the appended claims.
Claims (6)
1. A method for implementing idempotent interface messages, comprising:
acquiring a service request, and performing request deduplication processing in a first preset period based on the service request;
executing target processing according to the service request to obtain a processing state;
wherein the processing states include a success state, a failure state, and an existing state;
when the processing state is the existing state, after a second preset period, processing and checking are carried out according to the service request, and a processing result is obtained;
and when the processing state is the existing state, performing processing verification according to the service request after a second preset period to obtain a processing result, wherein the processing result comprises:
when the processing state is the existing state, the service request is saved through the client;
wherein the method further comprises:
storing the service request through an idempotent table or a cache;
after a second preset period, checking whether the target processing of the server side is successful or not through the service request of the client side, and obtaining a processing result;
wherein the second preset period is greater than the first preset period;
when the processing result is failure, returning to the step of executing target processing according to the service request to obtain a processing state until the processing state is a successful state or a failure state or the processing result is successful;
the failure states include a first failure state and a second failure state, the method further comprising:
deleting the service request in the idempotent table or the cache when the failure state is a first failure state;
when the failure state is the 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 the preset retry times are reached, the processing state of a successful state or the processing state of an existing state is obtained.
2. The method according to claim 1, wherein the performing the request deduplication processing within the first preset time period based on the service request comprises:
filtering the service request repeatedly acquired within a first preset period through a preset component of a server based on the service request of the client;
wherein the preset component comprises a database and redis.
3. The method for achieving idempotent of interface messages according to claim 1, further comprising:
and deleting the idempotent table or the service request in the cache when the processing state is a successful state or after a first preset period.
4. A system for effecting idempotent interface messages, comprising:
the first module is used for acquiring a service request, and carrying out request deduplication processing in a first preset period 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 states include a success state, a failure state, and an existing state;
the third module is used for performing processing verification according to the service request after a second preset period to obtain a processing result when the processing state is the existing state; wherein the second preset period is greater than the first preset period;
and when the processing state is the existing state, performing processing verification according to the service request after a second preset period to obtain a processing result, wherein the processing result comprises:
when the processing state is the existing state, the service request is saved through the client;
after a second preset period, checking whether the target processing of the server side is successful or not through the service request of the client side, and obtaining a processing result;
a fourth module, configured to return to the step of executing the target process according to the service request to obtain a processing state when the processing result is failure, until the processing state is obtained as a success state or a failure state, or the processing result is obtained as success
The failure states include a first failure state and a second failure state, the system further comprising:
means for saving the service request via an idempotent table or cache;
means for deleting the service request in the idempotent table or the cache when the failure state is a first failure state;
when the failure state is a second failure state, performing request retry processing based on the service request by the client;
and the module is used for retrying the processing according to the request, executing the target processing until the preset retrying times are reached, and obtaining the processing state of the successful state or the processing state of the existing state.
5. An apparatus for realizing idempotent of interface messages, comprising a processor and a memory;
the memory is used for storing programs;
the processor executing the program implements the method of any one of claims 1 to 3.
6. A computer-readable storage medium, characterized in that the storage medium stores a program that is executed by a processor to implement the method of any one of claims 1 to 3.
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 CN115658339A (en) | 2023-01-31 |
| CN115658339B true 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 |
|---|
| 基于微服务架构的数据一致性方法研究;杨成荣等;《电脑知识与技术》;第16卷(第8期);第266-268页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN115658339A (en) | 2023-01-31 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9715507B2 (en) | Techniques for reconciling metadata and data in a cloud storage system without service interruption | |
| US8380678B2 (en) | Tracking files which have been processed by a backup or a restore operation | |
| US9778998B2 (en) | Data restoration method and system | |
| CN105471714A (en) | Message processing method and device | |
| WO2017075130A1 (en) | Ensuring crash-safe forward progress of a system configuration update | |
| CN110019063B (en) | Method for computing node data disaster recovery playback, terminal device and storage medium | |
| US20150213051A1 (en) | System and method for high availability data replication | |
| CN112882655A (en) | Data caching method and device, electronic equipment and storage medium | |
| CN103838782B (en) | A kind of method and device realized file scan and preserved | |
| CN115658339B (en) | Method, system, device and storage medium for realizing idempotent of interface message | |
| US20200409683A1 (en) | Updating method, terminal and electronic device | |
| CN110928885B (en) | Method and device for updating data of Mysql database to Es database | |
| CN113301516A (en) | Method and system for rejecting duplicate messages during short message sending | |
| CN111371818B (en) | Data request verification method, device and equipment | |
| CN118151857A (en) | Data synchronization method, system, device, computer equipment and storage medium | |
| CN111078465A (en) | A data recovery method, device and computer-readable storage medium | |
| CN111427868A (en) | Processing method and device for operation request in database migration and electronic equipment | |
| CN107908370B (en) | Data storage method and device | |
| CN111045787B (en) | Rapid continuous experiment method and system | |
| CN115114245A (en) | A file deletion method and related equipment | |
| CN110209554B (en) | Database log distribution method, device and equipment | |
| CN115248827A (en) | Distributed transaction commit method and device | |
| CN112395345B (en) | HBase full data import method, device, computer equipment and storage medium | |
| CN111427720A (en) | Database repair method and device, computer equipment and storage medium | |
| 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 |