Methods and apparatus for processing object data, storage media and electronic devices

Abstract

This disclosure provides a method, apparatus, storage medium, and electronic device for processing object data. The method includes: upon receiving a data operation request from a target client, performing a first data operation on cached first object data to obtain second object data; sending a first data write request to a data storage node, the first data write request carrying the second object data and a first version identifier matching the first object data; if the first version identifier fails data version verification, retrieving third object data and a second version identifier matching the third object data from the data storage node; performing the first data operation on the third object data to obtain fourth object data, and sending a second data write request carrying the fourth object data and a second version identifier to the data storage node. This disclosure solves the technical problem of high network latency in related object data processing methods.

Description

Technical Field

[0001] This invention relates to the field of computers, and more specifically, to a method and apparatus for processing object data, a storage medium, and an electronic device. Background Technology

[0002] In distributed data systems, when multiple servers need to modify the same data, to resolve conflicts caused by multiple write operations on the same data object from multiple servers, the modification operations are typically restricted to a single target server. That is, multiple other servers asynchronously forward modification requests to the target server, thus achieving serial modification through the target server.

[0003] In the above implementation, after the data read and write operations initiated by each server are forwarded to the target server, the target server further processes multiple data write operations sequentially according to a locking mechanism or a queuing mechanism, and then sends data write requests to the database sequentially. Since the data write operations in the above method are performed asynchronously, significant network latency is introduced, resulting in the technical problem of high network latency in object data processing.

[0004] There is currently no effective solution to the above problems. Summary of the Invention

[0005] This invention provides a method and apparatus for processing object data, a storage medium, and an electronic device to at least solve the technical problem of high network latency in object data processing in related fields.

[0006] According to one aspect of the present invention, a method for processing object data is provided, comprising: upon receiving a data operation request sent by a target client, performing a first data operation on cached first object data to obtain second object data, wherein the first object data is used to describe a target data object corresponding to the data operation request; sending a first data write request to a data storage node, wherein the first data write request carries the second object data and a first version identifier matching the first object data, the data storage node being used to verify multiple data write requests and perform a write operation on object data according to the verification result, the multiple data write requests including the first data write request; if the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification, obtaining third object data and a second version identifier matching the third object data from the data storage node; performing the first data operation on the third object data to obtain fourth object data, and sending a second data write request carrying the fourth object data and the second version identifier to the data storage node, wherein the third object data is object data currently written to the data storage node and used to describe the target data object.

[0007] According to another aspect of the present invention, an object data processing apparatus is also provided, comprising: an operation unit, configured to perform a first data operation on cached first object data to obtain second object data upon receiving a data operation request sent by a target client; a first sending unit, configured to send a first data write request to a data storage node, wherein the first data write request carries the second object data and a first version identifier matching the first object data, the data storage node is configured to verify multiple data write requests and perform a write operation on the object data according to the verification result, the multiple data write requests including the first data write request; an acquisition unit, configured to acquire third object data and a second version identifier matching the third object data from the data storage node if the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification; and a second sending unit, configured to perform the first data operation on the third object data to obtain fourth object data and send a second data write request carrying the fourth object data and the second version identifier to the data storage node.

[0008] Optionally, the second sending unit includes: a first acquisition module for acquiring an operation instruction list, wherein the operation instruction list stores data operation instructions that match at least one of the data operation requests; a second acquisition module for acquiring a first data operation instruction from the operation instruction list; and an operation module for performing the first data operation on the third object data according to the first data operation instruction to obtain the fourth object data.

[0009] Optionally, the above-mentioned operation unit includes: a parsing module, configured to obtain the first object data corresponding to the data operation request from cached data according to the data operation request; parse the data operation request to obtain the first data operation instruction matching the data operation request; and a storage module, configured to store the first data operation instruction in the operation instruction list, and perform the first data operation on the first object data according to the first data operation instruction to obtain the second object data.

[0010] Optionally, the above-mentioned object data processing apparatus further includes: an instruction deletion unit, configured to receive the write verification result returned by the data storage node; if the write verification result indicates that the second version identifier has passed the data version verification, to search for the first data operation instruction in the operation instruction list; and to delete the first data operation instruction from the operation instruction list in response to finding the first data operation instruction.

[0011] Optionally, the above-mentioned object data processing apparatus further includes: an operation verification unit, configured to obtain an operation verification result matching the first data operation; if the operation verification result indicates that the second object data obtained by the first data operation has not been written to the data storage node, determine to perform the first data operation on the third object data; and if the operation verification result indicates that the second object data obtained by the first data operation has been written to the data storage node, delete the first data operation instruction from the operation instruction list.

[0012] Optionally, the operation verification unit is configured to: obtain an operation identifier list, wherein the operation identifiers in the operation identifier list are used to indicate historical data operations, and the object data corresponding to the historical data operations has been written to the data storage node; and if a data operation identifier indicating the first data operation is found in the operation identifier list, determine that the second object data obtained from the first data operation has been written to the data storage node.

[0013] Optionally, the operation verification unit is used for one of the following: obtaining the operation verification result matching the first data operation according to the locally stored operation identifier list, wherein the operation identifier in the operation identifier list is used to indicate historical data operations, and the object data corresponding to the historical data operations has been written to the data storage node; obtaining the operation verification result matching the first data operation from the data storage node, wherein the data storage node stores the operation identifier list used to verify data operations.

[0014] Optionally, the second sending unit is further configured to: send a third data write request to the data storage node if no write verification result is received from the data storage node within the target period, wherein the third data write request carries the second object data and the first version identifier that matches the first object data.

[0015] Optionally, the above-mentioned object data processing apparatus further includes: a third sending unit, configured to determine that the fourth object data has been written to the above-mentioned data storage node when the write verification result returned by the above-mentioned data storage node indicates that the second version identifier has passed the data version verification; send a data update instruction to at least one reference server; and return the data operation result to the above-mentioned target client.

[0016] Optionally, the third sending unit is configured to: send a first data update instruction to at least one of the reference servers, wherein the first data update instruction instructs at least one reference server to obtain updated object data and a data version identifier corresponding to the updated object data from the data storage node; and send a second data update instruction to at least one of the reference servers, wherein the data update instruction carries the fourth object data and the second version identifier.

[0017] Optionally, the above-mentioned object data processing apparatus further includes: a fourth sending unit, configured to determine that the second object data has been written to the above-mentioned data storage node when the write verification result returned by the above-mentioned data storage node indicates that the first version identifier has passed the data version verification; obtain a third version identifier matching the second object data from the above-mentioned data storage node; send a data update instruction to at least one reference server; and return the data operation result to the above-mentioned target client.

[0018] Optionally, the above-mentioned object data processing apparatus further includes one of the following: a first data acquisition unit, configured to determine a resource object matching the data operation request; acquire the first object data describing the resource object from cached data; and a second data acquisition unit, configured to determine a set of resource objects matching the data operation request, wherein the set of resource objects includes multiple subsets of resource objects, and resource objects in one subset of resource objects have the same resource attributes; determine a target subset of resource objects from the multiple subsets of resource objects, and acquire the first object data describing the target subset of resource objects from the cached data.

[0019] According to another aspect of the present invention, a computer-readable storage medium is also provided, wherein a computer program is stored in the computer program, wherein the computer program is configured to execute the above-described object data processing method at runtime.

[0020] According to another aspect of the embodiments of this application, a computer program product or computer program is provided, which includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the object data processing method as described above.

[0021] According to another aspect of the present invention, an electronic device is also provided, including a memory and a processor, wherein the memory stores a computer program and the processor is configured to execute the object data processing method described above through the computer program.

[0022] In the above-mentioned object data processing method, on the one hand, when a data operation request is received from the target client, the first data operation can be directly performed on the cached first object data in the current server to obtain the second object data; and a first data write request is sent to the data storage node, thereby realizing the quick modification of data in the current server cache based on the data operation request, which improves the efficiency of data operation.

[0023] On the other hand, further data version identification and data rewriting mechanisms are used to avoid write conflicts between multiple servers on the same data object. In the above implementation, since the first data write request carries the second object data and a first version identifier matching the first object data, data version verification can be performed on the first version identifier in the data storage node to avoid data write operation conflicts. If the verification fails, the third object data and a second version identifier matching the third object data are obtained from the data storage node; the first data operation is performed on the third object data to obtain the fourth object data, and a second data write request carrying the fourth object data and the second version identifier is sent to the data storage node, thereby achieving data consistency between the server and the data storage node based on the data rewriting mechanism.

[0024] The above implementation method modifies data based on local server cache, reducing latency during data modification and resolving the high network latency issue in related technical solutions. Furthermore, the combination of data version verification and data rewriting mechanisms ensures data consistency across data storage nodes, thereby significantly improving object data processing efficiency. Attached Figure Description

[0025] The accompanying drawings, which are included to provide a further understanding of the invention and form part of this application, illustrate exemplary embodiments of the invention and, together with their description, serve to explain the invention and do not constitute an undue limitation thereof. In the drawings:

[0026] Figure 1 This is a schematic diagram of the hardware environment for an optional object data processing method according to an embodiment of the present invention;

[0027] Figure 2 This is a flowchart of an optional object data processing method according to an embodiment of the present invention;

[0028] Figure 3 This is a schematic diagram of an optional object data processing network architecture according to an embodiment of the present invention;

[0029] Figure 4 This is a schematic diagram of another optional network architecture for processing object data according to an embodiment of the present invention;

[0030] Figure 5 This is a schematic diagram of an optional data version identifier according to an embodiment of the present invention;

[0031] Figure 6 This is a schematic diagram of another optional network architecture for processing object data according to an embodiment of the present invention;

[0032] Figure 7This is a schematic diagram of an optional object data processing scenario according to an embodiment of the present invention;

[0033] Figure 8 This is a timing diagram of an optional object data processing method according to an embodiment of the present invention;

[0034] Figure 9 This is a timing diagram of another optional object data processing method according to an embodiment of the present invention;

[0035] Figure 10 This is a timing diagram of another optional object data processing method according to an embodiment of the present invention;

[0036] Figure 11 This is a timing diagram of another optional object data processing method according to an embodiment of the present invention;

[0037] Figure 12 A schematic diagram of the structure of an optional object data processing apparatus according to an embodiment of the present invention;

[0038] Figure 13 This is a schematic diagram of the structure of an optional electronic device according to an embodiment of the present invention. Detailed Implementation

[0039] To enable those skilled in the art to better understand the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention.

[0040] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of the invention described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover a non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0041] It should be noted that in the relevant embodiments of this application, the acquisition and processing of relevant data information of the target account are all obtained in advance through methods that comply with the relevant normative legal documents, and the authorization permission of the corresponding account subject must be obtained before acquiring the above-mentioned relevant information and data.

[0042] The following explains the technical terms used in this application:

[0043] Distributed networks: A distributed network is a computer network system in which multiple independent computer nodes are interconnected and work collaboratively. These nodes can be located anywhere and share resources and coordinate actions through information exchange. In a distributed system, data and processing tasks can be distributed across multiple nodes, rather than concentrated on a single node. This architecture improves the system's reliability, scalability, and fault tolerance.

[0044] Data consistency refers to maintaining the same values ​​and state among multiple copies of data or data in different storage locations. Data consistency is a critical issue in distributed systems and concurrency control because multiple users or processes may update the same data simultaneously.

[0045] According to one aspect of the present invention, a method for processing object data is provided, which may be applied, but is not limited to, to... Figure 1 The hardware environment shown includes an object data processing system, which may include, but is not limited to, terminal device 102, network 104, server 106, database 108, and server 110. Terminal device 102 runs a game client for displaying virtual scenes in game tasks. Terminal device 102 includes a human-computer interaction screen, a processor, and a memory. The human-computer interaction screen in terminal device 102 is used to display the virtual scene and also provides a human-computer interaction interface to receive human-computer interaction operations for controlling a controlled virtual character in the virtual scene, which will complete game tasks set in the virtual scene. The processor is used to generate interaction instructions in response to the aforementioned human-computer interaction operations and send the interaction instructions to the server. The memory is used to store relevant attribute data, such as object attribute information of the controlled virtual character and attribute information of the virtual items it holds, etc. This attribute information may include, but is not limited to, information used to identify its identity and current location.

[0046] Furthermore, servers 106 and 110, along with database 108, form a distributed network. Servers 106 and 110 include processing engines that perform store or read operations on database 108. Specifically, the processing engines read virtual scene information and operation information for each virtual character from database 108.

[0047] Assumption Figure 1 The terminal device 102 runs a client for displaying virtual scenes, and the database 108 is the first data storage node. The specific process of this embodiment is as follows: Step S102 is executed through the terminal device 102, and in response to the interactive operation received in the terminal device 102, a data operation request is sent to the server 106 through the network 104.

[0048] Next, S104 is executed on server 106. Upon receiving a data operation request sent by the target client, a first data operation is performed on the cached first object data to obtain the second object data. Then, S106 is executed. Based on the second object data, a first data write request is sent to the data storage node. The first data write request carries the second object data and a first version identifier that matches the first object data. The data storage node is used to verify multiple data write requests and perform a write operation on the object data based on the verification result. The multiple data write requests include the first data write request.

[0049] Database 108 executes S108, returning the first write verification result to server 106; server 106 executes S110 and S112, and if the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification, it retrieves the third object data and the second version identifier that matches the third object data from the data storage node; it performs the first data operation on the third object data to obtain the fourth object data; and executes S114, sending a second data write request carrying the fourth object data and the second version identifier to the data storage node;

[0050] Next, database 108 executes S116 and returns the second write verification result to server 106. If the write verification result returned by the data storage node indicates that the second version identifier has passed the data version verification, server 106 executes S118 and returns the data operation result to terminal device 102 through network 104.

[0051] Optionally, in this embodiment, the terminal device 102 can be a terminal device configured with a target client, which may include, but is not limited to, at least one of the following: mobile phone (such as Android phone, iOS phone, etc.), laptop computer, tablet computer, PDA, MID (Mobile Internet Devices), PAD, desktop computer, smart TV, etc. The target client can be a video client, instant messaging client, browser client, educational client, or other client that supports providing shooting game tasks. The network may include, but is not limited to, wired network and wireless network, wherein the wired network includes: local area network, metropolitan area network, and wide area network, and the wireless network includes: Bluetooth, WIFI, and other networks that enable wireless communication. The server may be a single server, a server cluster composed of multiple servers, or a cloud server. The above is only an example, and no limitation is made in this embodiment.

[0052] Optionally, in this embodiment, the above-mentioned object data processing method can be applied, but is not limited to, to game-type terminal applications (APPs) that complete predetermined interactive game tasks in a virtual scene, such as an open-world game application. In an open-world game task, players can control virtual characters to freely explore, interact, and complete tasks in a vast, open virtual environment. This provides players with a high degree of freedom in their control operations and a non-linear experience of the game world.

[0053] The aforementioned object data processing method can also be applied to Multiplayer Online Battle Arena (MOBA) applications. In these MOBAs, players can control virtual characters to unleash character skills within a virtual environment, creating virtual objects. The interactive game tasks can be, but are not limited to, tasks completed by the current player through virtual social interaction between virtual characters in the virtual environment and other players' controlled virtual characters. This object data processing method can also be applied to massively multiplayer online role-playing games (MMORPGs). In these games, the current player can complete interactive game tasks from the first-person perspective of a virtual character, such as completing tasks together with other virtual characters. These interactive game tasks can, but are not limited to, run as plugins or mini-programs within an application (such as a non-standalone game app), or run within a game engine within an application (such as a standalone game app). The types of game applications mentioned above may include, but are not limited to, at least one of the following: two-dimensional (2D) game applications, three-dimensional (3D) game applications, virtual reality (VR) game applications, augmented reality (AR) game applications, and mixed reality (MR) game applications. This is merely an example, and this embodiment does not impose any limitations on it.

[0054] In the above-mentioned object data processing method, on the one hand, when a data operation request is received from the target client, the first data operation can be directly performed on the cached first object data in the current server to obtain the second object data; and a first data write request is sent to the data storage node, thereby realizing the quick modification of data in the current server cache based on the data operation request, which improves the efficiency of data operation.

[0055] On the other hand, further data version identification and data rewriting mechanisms are used to avoid write conflicts between multiple servers on the same data object. In the above implementation, since the first data write request carries the second object data and a first version identifier matching the first object data, data version verification can be performed on the first version identifier in the data storage node to avoid data write operation conflicts. If the verification fails, the third object data and a second version identifier matching the third object data are obtained from the data storage node; the first data operation is performed on the third object data to obtain the fourth object data, and a second data write request carrying the fourth object data and the second version identifier is sent to the data storage node, thereby achieving data consistency between the server and the data storage node based on the data rewriting mechanism.

[0056] The above implementation method modifies data based on local server cache, reducing latency during data modification and resolving the high network latency issue in related technical solutions. Furthermore, the combination of data version verification and data rewriting mechanisms ensures data consistency across data storage nodes, thereby significantly improving object data processing efficiency.

[0057] The above is merely an example, and no limitation is made in this embodiment.

[0058] As an optional implementation method, such as Figure 2 As shown, the above method for processing object data can be applied to a server, and specifically includes the following steps:

[0059] S202, upon receiving a data operation request from the target client, perform a first data operation on the cached first object data to obtain the second object data;

[0060] The first object data is used to describe the target data object corresponding to the data operation request.

[0061] S204, a first data write request is sent to the data storage node, wherein the first data write request carries second object data and a first version identifier matching the first object data. The data storage node is used to verify multiple data write requests and perform a write operation on the object data according to the verification result. The multiple data write requests include the first data write request.

[0062] S206, if the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification, obtain the third object data and the second version identifier that matches the third object data from the data storage node;

[0063] S208, perform a first data operation on the third object data to obtain the fourth object data, and send a second data write request carrying the fourth object data and the second version identifier to the data storage node.

[0064] Among them, the third object data is the object data currently written in the data storage node, which is used to describe the target data object.

[0065] In the above embodiments of this application, the target client in step S202 can be a client used to provide interactive operations with a user object. For example, the target client may include, but is not limited to, a game client for providing game interactive operations, a shopping client for providing virtual consumption operations, an instant messaging client for providing conversational interactive operations, and a video client for providing video playback interactive operations. It should be noted that this embodiment does not limit the specific type of the target client.

[0066] In the various types of clients described above, different types of data operation requests can be generated based on user interactions. For example, in a game client, a first game interaction can control a virtual game character to acquire virtual items in a virtual scene, thereby triggering an operation request for object data related to the quantity of virtual items. Similarly, a second game interaction can control a virtual game character to consume virtual game resources in a virtual scene to obtain virtual rewards, thereby triggering an operation request for object data related to the quantity of virtual game resources.

[0067] In a shopping client, in response to a purchase or transaction triggered through the shopping client, an object data operation request related to virtual resources can be triggered. The virtual resources in the shopping application may include, but are not limited to, electronic vouchers and electronic points. The object data operation request may update object data indicating the quantity of the electronic vouchers or electronic points; it may also update the quantity of the virtual goods object indicated by the purchase operation. Correspondingly, in an instant messaging client, in response to a friend addition operation, an object data operation request describing the quantity of friend objects can be triggered; in a video playback client, in response to a comment operation on a target video, an object data operation request describing the quantity of comment information for the target video can be triggered. In this embodiment, the correspondence between the client type of the target client and the request type of the data operation request is not limited.

[0068] As can be seen, in the aforementioned scenarios, to alleviate the pressure on server and database writes, data operations on object data can be triggered by multiple different clients, which then forward the data to their respective servers in the distributed network architecture for processing. For example, in scenarios such as... Figure 3 In the distributed network architecture shown, when the first server 306, the second server 308, and the third server 310 trigger their respective data modification requests, they will send their data modification requests to the target server 304. The target server 304 will then asynchronously process their respective data requests and return their corresponding data modification responses. Simultaneously, the target server 304 interacts with the database 302. Upon receiving a modification request for the same target data object, the target server 304 can serially write and modify the data of the object matching the target data object.

[0069] exist Figure 3 In the distributed network architecture shown, because all operations on multiple servers are asynchronous requests, code complexity will increase. For example... Figure 3 When the first server (306), the second server (308), and the third server (310) need to modify data, they all need to asynchronously request the target server (304) to make the modification, resulting in high complexity in the business logic code. Furthermore, due to the unstable communication links between servers... Figure 3 When data modification across multiple servers requires asynchronous requests, the success rate of data modification will be affected by network stability. In other words, under conditions of significant network fluctuations, Figure 3 The data processing method in this system suffers from a low data processing success rate. Furthermore, since data modifications on the first server 306, the second server 308, and the third server 310 require asynchronous requests, the business response to these data modifications inevitably introduces network latency associated with these asynchronous requests, significantly increasing the business response time.

[0070] By using steps S202 and S204 in the above embodiments of this application, when the server receives a data operation request sent by the target client, it can directly modify the data based on the memory data currently cached by the server, and send the modified data to the data storage node through a data write request. Thus, it can directly interact with the database without the need for an intermediate server, thereby improving the data write efficiency.

[0071] The distributed network architecture involved in this embodiment can be as follows: Figure 4As shown, when multiple distributed servers, including the first server 404 and the second server 406, can interact directly with the database 402 respectively. Upon receiving a data operation request from the target client, the data modifications made by the multiple servers, including the first server 404 and the second server 406, are based on the memory data cached by their respective servers. They then interact with the database 402 based on the updated data generated after the operation, i.e., requesting the database 402 to write the updated data.

[0072] It should be noted that, in the embodiments of this application, when database 402 is an independent database object, the data storage node in step S204 above can be specifically a database object; when the database is a distributed database, the data storage node in step S204 above can be specifically a distributed node included in the distributed database object.

[0073] Furthermore, the first data write request in step S204 above not only carries the second object data obtained by performing the first data operation on the first object data, but may also further include a first version identifier that matches the first object data. In this way, data version verification can be performed in the data storage node based on the first version identifier that matches the first object data to determine whether to write the second object data in the data storage node.

[0074] It should be noted that, in this embodiment, the above-mentioned data storage node can maintain a data version identifier for each data object, so as to verify the data write requests sent by each server according to the data version identifier.

[0075] In one optional implementation, the aforementioned data version identifier can be used to indicate the current object data sequence number of the aforementioned data object. For example, in a game application scenario, if the aforementioned data object is specifically the quantity of virtual items in a virtual game inventory, the item quantity can be determined as the aforementioned data object, and the current value of the item quantity can be determined as the current object data of the data object. For example, if the item quantity value is 0 at the first moment, the data version number corresponding to the value 0 can be determined to be 1; and if the item quantity value is updated to 1 at the second moment, the data version number corresponding to the value 1 can be determined to be updated to 2.

[0076] In another alternative implementation, the aforementioned data version identifier can be used to indicate the update time of the current object data of the aforementioned data object. For example, in a video application scenario, if the aforementioned data object is specifically the number of comments on a target video, the number of comments can be determined as the aforementioned data object, and the current value of the number of comments can be determined as the current object data of the data object. For example, if the value of the number of comments is 1000, the data version number corresponding to the value 1000 can be determined as the first hash value of its first update time; if the value of the number of comments is 10000, the data version number corresponding to the value 10000 can be determined as the second hash value of its second update time.

[0077] In another alternative implementation, the aforementioned data version identifier can be specifically a bitmap identifier comprising multiple byte segments, each segment indicating different verification information. For example... Figure 5 An optional composition of the data version identifier is shown. The data version identifier 500 may include 12 bytes of data, wherein the first and second bytes may carry server verification information; the third and fourth bytes may carry client verification information; the fifth and sixth bytes may carry sequence number verification information; and the remaining bytes may carry time verification information.

[0078] In a specific method for determining data version identifiers, a data storage node performs a data write operation based on a data write request sent by server A to obtain target object data. The written object data is the 1000th update result of the target object data, and the write time is the third update moment. The data write request sent by server A is generated based on a data operation request sent by client A. Furthermore, it can be based on... Figure 5 The data version identifier 500 shown in the diagram generates a target version identifier that matches the target object data. In the target version identifier, the first and second bytes can carry the server identifier of server A; the third and fourth bytes can carry the client identifier of client A; the fifth and sixth bytes can carry the verification information corresponding to sequence number 1000; and the remaining bytes can carry the hash value at the third update time.

[0079] In one optional implementation, before performing the first data operation on the cached first object data to obtain the second object data, one of the following is further included:

[0080] Method 1: Identify the resource object that matches the data operation request; retrieve the first object data describing the resource object from the cached data;

[0081] Method 2: Determine the set of resource objects that match the data operation request. The set of resource objects includes multiple subsets of resource objects, and the resource objects in a subset of resource objects have the same resource attributes. Determine the target subset of resource objects from the multiple subsets of resource objects, and obtain the first object data describing the target subset of resource objects from the cached data.

[0082] In Method 1 of this embodiment, when the resource object matched by the aforementioned data operation request is an indivisible resource object, the resource object can be described using first object data. For example, if the resource object matched by the aforementioned data operation request is the character level of a virtual character in a game application, the character level of the virtual character can be described using a level value. In Method 1, data operations can be directly performed on the first object data used to describe the resource object;

[0083] In the second embodiment of this application, when the resource object matched by the aforementioned data operation request is a divisible set of resource objects, the set of resource objects can be described by the number of objects included in each of the multiple resource object subsets. For example, if the data operation request is to update the first set of virtual resources (e.g., electronic points and electronic vouchers) held by the aforementioned first object account, the quantity of the aforementioned electronic points can be indicated by the first resource data, and the quantity of the aforementioned electronic vouchers can be indicated by the second resource data; thus, the resource objects can be described by different resource subsets and the object data corresponding to the resource subsets.

[0084] Optionally, the set of resource objects held by the aforementioned object account may include a type of virtual resource, which can also be described using different object data. For example, if the first set of virtual resources includes multiple electronic vouchers of different denominations, the quantity of electronic vouchers of the first denomination can be indicated by the first object data, and the quantity of electronic vouchers of the second denomination can be indicated by the second resource data.

[0085] In the above-mentioned method two, a target resource object subset and a first object data describing the target resource subset can be determined from the above resource object set according to the above resource processing request. Then, resource operations on the target resource subset can be implemented according to the data operations of the first object data. For example, in the above implementation, when the third resource data indicates the quantity of electronic vouchers of the first denomination and the fourth resource data indicates the quantity of electronic vouchers of the second denomination, it is determined that the above resource processing request is to consume one electronic voucher of the first denomination from the first object account. Then, the above third resource data is determined as the first target resource data to indicate that the set of electronic vouchers to be updated is the set of electronic vouchers of the first denomination.

[0086] In the above embodiments of this application, the resource subset corresponding to the data operation request and the corresponding first object data can be determined, and the first object data can be processed without affecting other servers to process the object data corresponding to other resource subsets, thereby significantly indicating the degree of concurrency in object data processing.

[0087] The data version identifier determined by the above embodiments of this application can assign unique identification information to object data when writing object data in the data storage node. Furthermore, when receiving write requests from multiple servers, verification based on the data version identifier can ensure data consistency. In addition, based on the server verification information and client verification information carried by the data version identifier, it is possible to further verify whether the data write request is a duplicate request, thereby avoiding duplicate data writing.

[0088] In an optional implementation, after sending the first data write request to the data storage node in step S202, the method further includes:

[0089] S1, if the write verification result returned by the data storage node indicates that the first version identifier has passed the data version verification, it is determined that the second object data has been written to the data storage node;

[0090] S2, obtain the third version identifier that matches the second object data from the data storage node;

[0091] S3 sends a data update command to at least one reference server and returns the data operation result to the target client.

[0092] It is understandable that after sending the first data write request to the data storage node, the data storage node can perform data version verification based on the first version identifier carried in the first data write request that matches the first object data, in order to verify and determine whether the second object data of the first data write request is obtained based on the latest first object data operation.

[0093] If the first version identifier of the first object data matches the target version identifier stored and maintained in the data storage node, it can be determined that the second object data was obtained based on the latest first object data, and then a write operation can be performed on the second object data.

[0094] Furthermore, in this embodiment, a third version identifier matching the second object data can be determined in the data storage node, and the third version identifier and the write verification result are synchronously sent to the current server so that the current server stores the third version identifier matching the second object data. It is understood that if the current server further receives a data operation request related to the second object data, it can send the result of the further operation and the aforementioned third version identifier to the data storage node so that data version verification can be performed in the data storage node.

[0095] In one alternative implementation, sending a data update instruction to at least one reference server includes at least one of the following:

[0096] Method 1: Send a first data update instruction to at least one reference server, wherein the first data update instruction is used to instruct at least one reference server to obtain the updated object data and the data version identifier corresponding to the updated object data from the data storage node;

[0097] Method 2: Send a third data update instruction to at least one reference server, wherein the data update instruction carries the second object data and a third version identifier that matches the second object data.

[0098] It should be noted that, in this embodiment, when it is determined that the second object data has been written to the data storage node, in addition to returning the writing result to the target client, other servers can also be notified synchronously to obtain the latest data cache and the latest data version identifier.

[0099] In the first notification method described above, other reference servers can be notified directly from the data storage node to obtain the updated object data and the data version identifier corresponding to the updated object data through the first data update instruction.

[0100] In the second notification method described above, the latest second object data and the third version identifier matching the second object data can be directly sent or broadcast to other servers via a third data update command, thereby improving the efficiency of cached data synchronization. In the current notification method, the system architecture of the distributed data processing system can be further updated as follows: Figure 6 As shown, while the first server 604 and the second server 606 are directly interacting with the database 602 to write data, the latest cached data and data version can also be broadcast among multiple servers when a data write request sent by one server is successful and the latest object data and data version are obtained, thereby improving the efficiency of cached data synchronization.

[0101] In the third notification method, a first data update instruction can be sent to a first group of servers among multiple servers, and a third data update instruction can be sent to a second group of servers. For example, the first group of servers could be servers whose communication latency with the current server is higher than a target threshold, while the second group of servers could be servers whose communication latency with the current server is lower than or equal to the target threshold. This allows for the dynamic selection of different notification instructions based on the network connection status between the current server and other servers, thereby improving data synchronization efficiency while ensuring data synchronization reliability.

[0102] In another verification result, as in steps S206 and S208 of the above embodiments, if the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification, the third object data and the second version identifier matching the third object data are obtained from the data storage node; the first data operation is performed on the third object data to obtain the fourth object data, and a second data write request carrying the fourth object data and the second version identifier is sent to the data storage node.

[0103] It is understood that, in the above implementation, if the first version identifier fails the data version verification, the latest object data (i.e., the third object data) returned by the data storage node and the matching latest version identifier can be used to perform data redo in the current server through the above step S208, and the redo result and the latest version identifier can be resent to the data storage node, thereby ensuring the data consistency between the server and the database.

[0104] The above implementation method modifies data based on local server cache, reducing latency during data modification and resolving the high network latency issue in related technical solutions. Furthermore, the combination of data version verification and data rewriting mechanisms ensures data consistency across data storage nodes, thereby significantly improving object data processing efficiency.

[0105] In one optional implementation, the above-described process of performing the first data operation based on the third object data to obtain the fourth object data includes:

[0106] S1, Obtain an operation instruction list, wherein the operation instruction list is used to store data operation instructions that match at least one data operation request;

[0107] S2, retrieve the first data operation instruction from the operation instruction list;

[0108] S3, perform the first data operation on the third object data according to the first data operation instruction to obtain the fourth object data.

[0109] It is understood that, in this embodiment, before performing data replay based on the latest third object data obtained from the data storage node, a pre-stored first data operation instruction can be obtained from the operation instruction list. Then, the first data operation is performed again on the third object data based on the first data operation instruction.

[0110] In this embodiment, the aforementioned first data operation instruction and first data operation can be associated with the specific data operation request in step S202. For example, in a game scenario, if the data operation request is "increment the quantity of virtual items in the virtual backpack by 1", then the aforementioned first data operation is specifically a "add 1 to the latest item quantity", and the aforementioned first data operation instruction can be specifically a "value increment" instruction; as another example, in a video playback scenario, if the data operation request is "increment the number of bullet comments in the target video by 1000", then the aforementioned first data operation is specifically an operation of "add 1000 to the latest bullet comment value", and the aforementioned first data operation instruction can be specifically a "value increment 1000" instruction.

[0111] It is understood that, in an optional implementation, when performing a first data operation on the cached first object data in step S202 above, the first data operation instruction can be pre-stored in the above operation instruction list.

[0112] Furthermore, upon receiving a data operation request from the target client, a first data operation is performed on the cached first object data to obtain the second object data, including:

[0113] S1, based on the data operation request, retrieve the first object data corresponding to the data operation request from the cached data;

[0114] S2, parse the data operation request and obtain the first data operation instruction that matches the data operation request;

[0115] S3, store the first data operation instruction in the operation instruction list, and perform the first data operation on the first object data according to the first data operation instruction to obtain the second object data.

[0116] Optionally, such as Figure 4 As shown, after modifications are made based on memory data in the first server 404 or the second server 406, the operation instructions are stored in the data synchronization module at the logical lower level of the current server. It can be understood that the aforementioned data synchronization module stores the list of operation instructions.

[0117] It is understood that in this embodiment, while performing data operations based on cached data in the current server, the operation instructions can be pre-stored in the operation instruction list. Then, when the write verification result returned by the data storage node indicates that the data version verification has failed, the latest data and data version number returned by the data storage node, as well as the pre-stored operation instructions, are used to redo the operation on the latest data to obtain a new set of data. The latest data and data version number are then sent to the operation instructions, and the operation instructions store the latest data, thereby ensuring the consistency of data operations in the distributed data processing system.

[0118] In an optional implementation, after sending the second data write request carrying the fourth object data and the second version identifier to the data storage node, the method further includes:

[0119] S1, receive the write verification result returned by the data storage node;

[0120] S2, if the write verification result indicates that the second version identifier has passed the data version verification, search for the first data operation instruction in the operation instruction list;

[0121] S3, in response to finding the first data operation instruction, delete the first data operation instruction from the operation instruction list.

[0122] It is understandable that the operation instructions stored in the operation instruction list are used to perform data replay. In the above implementation, after sending the second data write request based on the third object data obtained after data replay, if the write verification result returned by the data storage node indicates that the second version identifier has passed the data version verification, it can be determined that the write operation on the fourth object data has been completed in the data storage node, that is, the data operation matching the data operation request sent by the target client has been completed. Therefore, the first data operation instruction in the operation instruction list can be deleted to avoid errors in data updates caused by redundant replay operations.

[0123] In an optional implementation, after sending the second data write request carrying the fourth object data and the second version identifier to the data storage node, the method further includes:

[0124] S1, if the write verification result returned by the data storage node indicates that the second version identifier has passed the data version verification, it is determined that the fourth object data has been written to the data storage node.

[0125] S2, send a data update command to at least one reference server and return the data operation result to the target client.

[0126] Understandably, in this embodiment, when fourth object data is obtained by performing data replay on the third object data, a second data write request can be sent to the data storage node. If the write verification result returned by the data storage node indicates that the second version identifier has passed the data version verification, it can be determined that the fourth object data has been written to the data storage node. Then, based on the write result, the corresponding data operation result can be fed back to the target server, and data update instructions can be sent to other reference servers.

[0127] In one alternative implementation, sending a data update instruction to at least one reference server includes at least one of the following:

[0128] Method 1: Send a first data update instruction to at least one reference server, wherein the first data update instruction is used to instruct at least one reference server to obtain the updated object data and the data version identifier corresponding to the updated object data from the data storage node;

[0129] Method 2: Send a second data update instruction to at least one reference server, wherein the data update instruction carries fourth object data and a second version identifier.

[0130] In the first notification method described above, other reference servers can be notified directly from the data storage node to obtain the updated object data and the data version identifier corresponding to the updated object data through the first data update instruction.

[0131] In the second notification method described above, the latest fourth object data and the second version identifier matching the fourth object data can be sent or broadcast directly to other servers through the second data update instruction, thereby improving the efficiency of cached data synchronization.

[0132] In the third notification method, a first data update instruction can be sent to a first group of servers among multiple servers, and a second data update instruction can be sent to a second group of servers. For example, the first group of servers could be servers whose communication latency with the current server is higher than a target threshold, while the second group of servers could be servers whose communication latency with the current server is lower than or equal to the target threshold. This allows for the dynamic selection of different notification instructions based on the network connection status between the current server and other servers, thereby improving data synchronization efficiency while ensuring data synchronization reliability.

[0133] The following combination Figure 7 The game interface shown illustrates one specific implementation method. In this implementation, the game scene interface displayed on the target client can be as follows: Figure 7 As shown. The target virtual character 701 currently controlled by the user is displayed in the center of the interface. Figure 7The interface shown also displays shooting controls for controlling the target virtual character to perform shooting actions, movement controls for controlling the target virtual character to move within the game scene, aiming controls for controlling the target virtual character to perform aiming operations, and a backpack control for controlling the display of the backpack area corresponding to the virtual backpack of the virtual object. Furthermore, in... Figure 7 In the game scene shown, a virtual object 705 is displayed on the ground. When the target virtual character 701 approaches the virtual object 705, a backpack list 702 corresponding to the backpack control 709 can be displayed in the virtual scene, showing that the target virtual character currently holds 7 virtual items. Then, in response to a pickup operation of the virtual object 705, i.e., confirming that the target virtual character 701 already holds the virtual object 705 as a virtual item, the item list needs to be updated to "8". Based on this, the target client can send a data operation request to the current server to update the number of items in the backpack.

[0134] Specifically, such as Figure 8 As shown, the distributed object data processing system may include a first server 802, a second server 804, and a database 806. In the initial stage, the knapsack data in the first server 802, the second server 804, and the database 806 has an initial data version number of 1.

[0135] Next, the first server 802 executes the data operation request sent by the target client, S802, adds item A to the backpack; S804, modifies the backpack cache, and adds the instruction matching the item addition operation to the operation instruction list;

[0136] In the above steps, the first server 802 first adds item information, including item quantity and attribute information, to the backpack cache data. Next, it adds the item operation command `add_cmd` to the operation command list. In this embodiment, the operation command list is mainly used to achieve data consistency by replaying data in case of version number conflicts.

[0137] For example, S806 sends a backpack data storage instruction to database 806, and the instruction carries version number information: data version number = 1;

[0138] Database 806 executes S808 to check the data version number and confirm that there is no conflict; S810, storage is successful, update the data version number to 2; and executes S812 to return a data storage success indication message to the first server 802, and return the data version number = 2.

[0139] In this embodiment, if the database 806 detects that two version numbers are equal, it can determine that there is no conflict in the data version numbers, and therefore runs the data to update.

[0140] The first server 802 executes S814 to update the data version number to 2; S816 to clear the operation instruction list; and executes S818 to notify the second server that the backpack data has been updated.

[0141] In this embodiment, since only one item operation command, add_cmd, is stored in the operation command list, the pre-stored operation commands can be cleared by clearing the operation command list.

[0142] Next, in response to the notification message sent by the first server 802, the second server 804 executes S820 to request the database 806 to retrieve the backpack data; executes S822 to the database 806, returning the backpack data and data version number = 2; the second server 804 executes S824 to update the backpack cache data and data version number.

[0143] In another implementation, after receiving the write result indication information returned by the database 806, the first server 802 can also directly send the latest object data and data version identifier to the second server 804.

[0144] Specifically, such as Figure 9 As shown, database 806 executes S810, stores data successfully, updates data version number to 2; and executes S812, returns a data storage success indication message to the first server 802, and returns data version number 2.

[0145] The first server 802 executes S814 to update the data version number to 2; S816 to clear the operation instruction list; and executes S819 to notify the second server that the backpack data has been updated based on the latest backpack data and the data version number = 2.

[0146] The second server 806 executes S826, storing the latest backpack data and data version number = 2; then executes S828, adding item B to the backpack; S830, modifies the backpack cache, and adds the command matching the item addition operation to the operation command list;

[0147] The second server 806 executes S832, sending a backpack data storage instruction to the database 806. The instruction carries version number information: data version number = 2.

[0148] Database 806 executes S834 to check the data version number and confirm that there is no conflict; S836, storage is successful, and the data version number is updated to 3; S838, data storage success indication information is returned to the second server 804, and the data version number is returned as 3.

[0149] The second server 804 executes S840, notifying the first server that the backpack data has been updated based on the latest backpack data and the data version number = 3.

[0150] Understandably, in this implementation, multiple servers can broadcast the latest object data and data version identifier after completing the data writing process, thereby improving the data cache synchronization efficiency.

[0151] The following combination Figure 10 This document describes the handling process for a situation where a second server concurrently modifies backpack data while a first server adds items to the backpack, resulting in a conflict in data version numbers.

[0152] In this embodiment, in the initial state, the initial data version number of the backpack data in the first server 1002, the second server 1004 and the database 1006 is 1; then, the second server 1004 updates the backpack data in the database, and the data version number in the database 1006 and the second server 1004 is 2.

[0153] Server 1002 executes S1002, adding item A to the inventory; S1004, modifies the inventory cache, and adds the command matching the item addition operation to the operation command list;

[0154] First server 1002 executes S1006, sending a backpack data storage instruction to database 1006. The instruction carries version number information: data version number = 1.

[0155] Database 1006 executes S1008, checks the data version number, and determines that there is a conflict in the data version number; S1010, abandons the data storage operation; S1012, returns a data storage failure indication message to the first server 1002, and returns the latest backpack data, and the latest data version number = 2;

[0156] In the above steps, after database 1006 receives the data update request from the first server 1002, it compares the data version number of database 1006 with the data version number in the request, finds that the data version numbers are inconsistent, and then determines that the data update has failed to be returned to the first server 1002, along with the latest data and the data version number.

[0157] First server 1002 executes S1014, updates the cache with the latest backpack data, and updates the data version number to 2; S1016, according to the operation instructions stored in the operation instruction list, re-executes the data update operation; First server 1002 executes S1018, sends a backpack data storage instruction to database 1006, the instruction carrying version number information: data version number = 2.

[0158] In the above steps, when the first server 1002 receives a data update failure message from the database 1006, it updates the backpack cache data and data version number with the latest data, and then re-executes the operation instruction list (re-adding item A). After the execution is completed, it sends the backpack data and data version number = 2 to the database 1006 again to request data update.

[0159] Database 1006 executes S1020, checks the data version number, and confirms that there is no conflict in the data version number; S1022, storage is successful, and the data version number is updated to 3; S1024, a data storage success indication message is returned to the first server 1002, and the data version number is returned as 3.

[0160] First server 1002 executes S1026, updates data version number = 3; S1028, clears the operation instruction list; S1030, notifies second server that there is an update to the backpack data;

[0161] Second server 1004 executes S1032, requesting to retrieve backpack data from database 1006; database 1006 executes S1034, returning backpack data and data version number = 3; second server 1004 executes S1036, updating backpack cache data and data version number.

[0162] In the above-mentioned object data processing method, on the one hand, when a data operation request is received from the target client, the first data operation can be directly performed on the cached first object data in the current server to obtain the second object data; and a first data write request is sent to the data storage node, thereby realizing the quick modification of data in the current server cache based on the data operation request, which improves the efficiency of data operation.

[0163] On the other hand, further data version identification and data rewriting mechanisms are used to avoid write conflicts between multiple servers on the same data object. In the above implementation, since the first data write request carries the second object data and a first version identifier matching the first object data, data version verification can be performed on the first version identifier in the data storage node to avoid data write operation conflicts. If the verification fails, the third object data and a second version identifier matching the third object data are obtained from the data storage node; the first data operation is performed on the third object data to obtain the fourth object data, and a second data write request carrying the fourth object data and the second version identifier is sent to the data storage node, thereby achieving data consistency between the server and the data storage node based on the data rewriting mechanism.

[0164] The above implementation method modifies data based on local server cache, reducing latency during data modification and resolving the high network latency issue in related technical solutions. Furthermore, the combination of data version verification and data rewriting mechanisms ensures data consistency across data storage nodes, thereby significantly improving object data processing efficiency.

[0165] In an optional implementation, after obtaining the third object data and the second version identifier matching the third object data from the data storage node when the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification, the method further includes:

[0166] S1, obtain the operation verification result that matches the first data operation;

[0167] S2, if the operation verification result indicates that the second object data obtained from the first data operation has not been written to the data storage node, determine to perform the first data operation on the third object data;

[0168] S3, if the operation verification result indicates that the second object data obtained from the first data operation has been written to the data storage node, delete the first data operation instruction from the operation instruction list.

[0169] It is understandable that, in this embodiment, in order to avoid repeatedly executing the same data operation request multiple times, further operation verification can be performed if the data version verification fails, in order to determine whether the current data operation has been executed.

[0170] Specifically, if data version verification fails, at least two scenarios are possible. In the first scenario, the first object data stored on the server is not the latest data. Therefore, the corresponding first version identifier does not match the latest data version identifier stored in the data storage node, leading to the data version verification failing. This means that the second object data was not obtained by performing the first data operation on the data storage node without first object data being written. In this scenario, the data operation request sent by the target client is not actually completed. Therefore, data replay is needed to complete the data operation request sent by the target client. This requires the implementation of step S208 and its related steps.

[0171] In the second scenario, the first object data stored on the current server is the latest data. Therefore, the corresponding first version identifier can match the latest data version identifier stored on the data storage node. This allows the data storage node to execute the first data operation after writing the first object data, obtaining the second object data. However, during the process of the data storage node returning the write result to the current server, network jitter causes the returned write result information to fail to reach the current server. In this scenario, the data operation request sent by the target client has actually been completed, but due to network jitter, the corresponding write result has not been received, leading the current server to re-trigger the write request. In this situation, the data storage node should be prevented from rewriting based on the re-triggered write request.

[0172] The operation verification result in the above embodiments of this application can be used to indicate whether the second object data obtained from the first data operation has been written to the data storage node, and then determine whether to trigger data replay in the current server based on the operation verification result.

[0173] In one optional implementation, obtaining the operation verification result matching the first data operation includes:

[0174] S1, obtain the operation identifier list, where the operation identifiers in the operation identifier list are used to indicate historical data operations, and the object data corresponding to the historical data operations has been written to the data storage node.

[0175] S2, if a data operation identifier indicating the first data operation is found in the operation identifier list, it is determined that the second object data obtained from the first data operation has been written to the data storage node.

[0176] In this embodiment, an operation identifier list can be added to the data. When data is modified and stored in the database, an operation identifier for this business storage is generated and inserted into the operation identifier list for storage. This operation identifier list prevents operation instructions from being executed repeatedly.

[0177] In one alternative implementation, the operation identifier list can be stored in a data storage node and maintained by the data storage node. The current server can obtain the operation identifier list from the data storage node.

[0178] When the storage operation of object data sent to the current server is completed in the data storage node, the request identifier of the data write request can be added to the aforementioned operation identifier list to indicate that the write operation has been completed. In this embodiment, the data storage node can maintain the operation identifier list according to the data write status. Furthermore, when sending third object data and a second version identifier matching the third object data to the current server, the operation identifier list is simultaneously sent to the current server. Based on this, the current server determines whether the first data operation has been completed and whether it needs to be replayed based on the operation identifier list.

[0179] In another optional implementation, the aforementioned operation identifier list can be stored on the current server, which maintains its local operation identifier list. In this implementation, each update operation can be assigned a corresponding operation identifier each time the locally cached object data is updated. Then, if a data update failure is received from the data storage node, the server checks its locally maintained operation identifier list. If the operation identifier to be stored is already in the list of successfully stored operation identifiers, it indicates that the update has already been successful. Therefore, the operation instruction list will not be replayed; it only needs to be cleared.

[0180] In one optional implementation, obtaining the operation verification result matching the first data operation includes one of the following:

[0181] Method 1: Based on the operation identifier list stored locally, obtain the operation verification result that matches the first data operation. The operation identifier in the operation identifier list is used to indicate historical data operations. The object data corresponding to the historical data operations has been written to the data storage node.

[0182] Method 2: Obtain the operation verification result matching the first data operation from the data storage node. The data storage node stores a list of operation identifiers used to verify the data operation.

[0183] In the first method described above, the operation verification result matching the first data operation can be obtained based on the locally stored list of operation identifiers.

[0184] In method two above, operation verification can be performed using a data storage node based on a pre-stored list of operation identifiers, and the verification result can be sent to the current server. Correspondingly, the current server can retrieve the operation verification result from the data storage node.

[0185] In one optional implementation, before obtaining the third object data and the second version identifier matching the third object data from the data storage node when the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification, the method further includes: if no write verification result is received from the data storage node within the target period, sending a third data write request to the data storage node, wherein the third data write request carries the second object data and the first version identifier matching the first object data.

[0186] It is understood that, in the above implementation, after the current server sends the first data write request to the data storage node, it can detect whether the data storage node returns a write verification result within the target period. If no write verification result is received within the target period, the second object data and the first version identifier matching the first object data can be resent to the data storage node according to the third data write request.

[0187] If no write verification result is received within the target period, there may be two scenarios:

[0188] In the first scenario, due to network fluctuations, the initial data write request may not reach the data storage node. In other words, the second object data has not yet been written to the data storage node. Therefore, a third data write request can be used to resend the second object data and a first version identifier matching the first object data to the data storage node. The data storage node then performs version verification based on the first version identifier. If the verification passes, the second object data is rewritten to the data storage node.

[0189] In the second scenario, the data storage node has already written the second object data based on the first data write request. However, due to network fluctuations, the write verification result returned to the current server has not reached the data storage node. In other words, the second object data has already been written to the data storage node. In this embodiment, upon receiving the aforementioned third data write request, the data storage node can determine, based on the data version verification result, not to write the second object data again. While returning the write verification result corresponding to the third data write request to the current server, it also needs to perform operation verification on the current server to ensure that the second object data is not recalculated.

[0190] The following combination Figure 11The process for handling version number conflicts caused by duplicate storage due to network jitter is explained. In this embodiment, in the initial state, the initial data version number of the backpack data in the first server 1102, the second server 1104, and the database 1106 is 1;

[0191] Server 1102 executes S1102, adding item A to the inventory; S1104, modifies the inventory cache, and adds the command matching the item addition operation to the operation command list;

[0192] The first server 1102 executes S1106, sending a backpack data storage instruction to the database 1106. The instruction carries version number information: data version number = 1.

[0193] Database 1106 executes S1108, checks the data version number, and confirms that the data version numbers are equal; S1110, storage is successful, data version number = 2; Database 1106 executes S1112, and returns a data storage success indication message to the first server 1102 (message lost).

[0194] In the above steps, after receiving the data update request from the first server 1102, database 1106 checks the data version number stored in database 1106 against the data version number in the request. Finding that the versions match, it updates the data. Simultaneously, it returns a successful data update message to the first server 1102, including the latest data version number. However, due to a network failure, the successful data update message returned by database 1106 to the first server 1102 is lost, and the first server 1102 does not receive this notification message.

[0195] First server 1102 executes S1114, storage timeout, retry; S1116, sends a backpack data storage instruction to database 1106, the instruction carries version number information: data version number = 1;

[0196] In step S1114 above, if the first server 1102 does not receive a response message for data update, it will try again to request data update from database 1106 using cached data and data version number after a certain timeout.

[0197] Database 1106 executes S1118, checks the data version number, determines that the data version number conflict, and does not update the data; S1124, returns a data storage failure indication message to the first server 1102, and returns the latest data and data version number = 2;

[0198] The first server 1102 executes S1126, checks the list of stored identifiers in the data, and confirms that the data has been successfully stored; S1128, updates the data version number to 2, and clears the operation instruction list;

[0199] In the above steps, after receiving a data update failure report from database 1106, the first server 1102 updates the cached data with the latest data and updates the data version number. The data contains a list of successfully stored operation identifiers. If, by checking, the operation identifier to be stored already exists in this list, it indicates that the update in database 1106 has been successful. At this point, the operation instruction list will not be replayed; it will simply be cleared.

[0200] First server 1102 executes S1130, notifying second server that the backpack data has been updated; second server 1104 executes S1132, requesting to retrieve backpack data; database 1106 executes S1134, returning backpack data and data version number = 2 to second server 1104; second server 1104 executes S1136, updating backpack cache data and data version number.

[0201] In another alternative implementation, the aforementioned operation identifier list can be maintained in database 1106. Upon successful response to the data write request for "Add Item A," i.e., successful write, the operation identifier for the write operation is added to the operation identifier list. Upon receiving a second data write request for "Add Item A" from the first server 1102, the data version identifier can be verified (since the data version identifiers are inconsistent, there is no need to rewrite in database 1106). Simultaneously, the replay operation can be verified based on the operation identifier list. According to the operation identifiers pre-stored in the list, it can be determined that the operation has been completed. Therefore, while sending a data write failure message to the first server 1102, the operation verification result can also be sent synchronously to indicate that the first server 1102 does not need to perform a data replay operation.

[0202] Through the above-described embodiments of this application, in such a way... Figure 4 or Figure 6 In the distributed network architecture shown, during the processing of object data, a data version number is first added to the data. When the data is modified, the data version number needs to be included. If the data version number is equal to the data version number in the database, the data can be modified; if the data version number is not equal, the verification fails and the modification fails, thus ensuring the consistency of data modification operations.

[0203] Furthermore, when data version number verification fails, the database returns the latest data and data version number to the server. The server then re-executes the operation instructions based on the latest data to obtain new data, which is then stored using the latest data and data version number. This achieves eventual data consistency between the server and the database.

[0204] Finally, in this embodiment, an order ID list can be added to the data. When data is modified and stored in the database, a storage operation identifier for this business storage is generated and inserted into the storage operation identifier list for storage. This storage operation identifier list is mainly used to prevent operation instructions from being executed repeatedly. If the data modification fails version verification, it is necessary to first check whether the current operation identifier already exists in the storage operation identifier list. If the current operation identifier already exists, it means that the data has been modified successfully, and there is no need to replay the operation instruction, thereby avoiding duplicate data operations.

[0205] Through the above implementation method, since data modification operations can be performed directly in the server memory without the need for asynchronous requests through an intermediate server, the code execution efficiency is high. Furthermore, since data modification is based on memory, the operation performance is higher than that based on asynchronous requests through an intermediate server. In addition, since data modification is based on server memory and does not require asynchronous interaction through the network, the business response reduces network latency, thus solving the technical problems of high data processing latency and low efficiency in existing object data processing.

[0206] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that the present invention is not limited to the described order of actions, because according to the present invention, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions and modules involved are not necessarily essential to the present invention.

[0207] According to another aspect of the present invention, an apparatus for processing object data for implementing the above-described object data processing method is also provided. For example... Figure 12 As shown, the device includes:

[0208] Operation unit 1202 is used to perform a first data operation on the cached first object data to obtain the second object data when a data operation request is received from the target client;

[0209] The first sending unit 1204 is used to send a first data write request to the data storage node. The first data write request carries the second object data and a first version identifier that matches the first object data. The data storage node is used to verify multiple data write requests and perform a write operation on the object data according to the verification result. The multiple data write requests include the first data write request.

[0210] The acquisition unit 1206 is used to acquire third object data and a second version identifier that matches the third object data from the data storage node when the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification.

[0211] The second sending unit 1208 is used to perform the first data operation on the third object data to obtain the fourth object data, and send a second data write request carrying the fourth object data and the second version identifier to the data storage node.

[0212] Optionally, the second sending unit 1208 includes: a first acquisition module for acquiring an operation instruction list, wherein the operation instruction list stores data operation instructions that match at least one of the data operation requests; a second acquisition module for acquiring a first data operation instruction from the operation instruction list; and an operation module for performing the first data operation on the third object data according to the first data operation instruction to obtain the fourth object data.

[0213] Optionally, the above-mentioned operation unit 1202 includes: a parsing module, configured to obtain the first object data corresponding to the data operation request from cached data according to the data operation request; parse the data operation request to obtain the first data operation instruction matching the data operation request; and a storage module, configured to store the first data operation instruction in the operation instruction list, and perform the first data operation on the first object data according to the first data operation instruction to obtain the second object data.

[0214] Optionally, the above-mentioned object data processing apparatus further includes: an instruction deletion unit, configured to receive the write verification result returned by the data storage node; if the write verification result indicates that the second version identifier has passed the data version verification, to search for the first data operation instruction in the operation instruction list; and to delete the first data operation instruction from the operation instruction list in response to finding the first data operation instruction.

[0215] Optionally, the above-mentioned object data processing apparatus further includes: an operation verification unit, configured to obtain an operation verification result matching the first data operation; if the operation verification result indicates that the second object data obtained by the first data operation has not been written to the data storage node, determine to perform the first data operation on the third object data; and if the operation verification result indicates that the second object data obtained by the first data operation has been written to the data storage node, delete the first data operation instruction from the operation instruction list.

[0216] Optionally, the operation verification unit is configured to: obtain an operation identifier list, wherein the operation identifiers in the operation identifier list are used to indicate historical data operations, and the object data corresponding to the historical data operations has been written to the data storage node; and if a data operation identifier indicating the first data operation is found in the operation identifier list, determine that the second object data obtained from the first data operation has been written to the data storage node.

[0217] Optionally, the operation verification unit is used for one of the following: obtaining the operation verification result matching the first data operation according to the locally stored operation identifier list, wherein the operation identifier in the operation identifier list is used to indicate historical data operations, and the object data corresponding to the historical data operations has been written to the data storage node; obtaining the operation verification result matching the first data operation from the data storage node, wherein the data storage node stores the operation identifier list used to verify data operations.

[0218] Optionally, the second sending unit 1208 is further configured to: send a third data write request to the data storage node if no write verification result is received from the data storage node within the target period, wherein the third data write request carries the second object data and the first version identifier that matches the first object data.

[0219] Optionally, the above-mentioned object data processing apparatus further includes: a third sending unit, configured to determine that the fourth object data has been written to the above-mentioned data storage node when the write verification result returned by the above-mentioned data storage node indicates that the second version identifier has passed the data version verification; send a data update instruction to at least one reference server; and return the data operation result to the above-mentioned target client.

[0220] Optionally, the third sending unit is configured to: send a first data update instruction to at least one of the reference servers, wherein the first data update instruction instructs at least one reference server to obtain updated object data and a data version identifier corresponding to the updated object data from the data storage node; and send a second data update instruction to at least one of the reference servers, wherein the data update instruction carries the fourth object data and the second version identifier.

[0221] Optionally, the above-mentioned object data processing apparatus further includes: a fourth sending unit, configured to determine that the second object data has been written to the above-mentioned data storage node when the write verification result returned by the above-mentioned data storage node indicates that the first version identifier has passed the data version verification; obtain a third version identifier matching the second object data from the above-mentioned data storage node; send a data update instruction to at least one reference server; and return the data operation result to the above-mentioned target client.

[0222] Optionally, the above-mentioned object data processing apparatus further includes one of the following: a first data acquisition unit, configured to determine a resource object matching the data operation request; acquire the first object data describing the resource object from cached data; and a second data acquisition unit, configured to determine a set of resource objects matching the data operation request, wherein the set of resource objects includes multiple subsets of resource objects, and resource objects in one subset of resource objects have the same resource attributes; determine a target subset of resource objects from the multiple subsets of resource objects, and acquire the first object data describing the target subset of resource objects from the cached data.

[0223] Optionally, in this embodiment, the implementation of each of the above-mentioned unit modules can be referred to the above-mentioned method embodiments, which will not be repeated here.

[0224] According to another aspect of the present invention, an electronic device for implementing the above-described object data processing method is also provided. This electronic device may be... Figure 13 The terminal device or server shown. This embodiment uses this electronic device as an example for illustration. Figure 13 As shown, the electronic device includes a memory 1302 and a processor 1304. The memory 1302 stores a computer program, and the processor 1304 is configured to execute the steps of any of the above method embodiments through the computer program.

[0225] Optionally, in this embodiment, the aforementioned electronic device may be located in at least one of a plurality of network devices in a computer network.

[0226] Optionally, in this embodiment, the processor can be configured to perform the following steps via a computer program:

[0227] S1, upon receiving a data operation request from the target client, performs a first data operation on the cached first object data to obtain the second object data;

[0228] S2, a first data write request is sent to the data storage node, wherein the first data write request carries the second object data and a first version identifier matching the first object data, and the data storage node is used to verify the multiple data write requests and perform a write operation on the object data according to the verification result, wherein the multiple data write requests include the first data write request.

[0229] S3, if the write verification result returned by the above data storage node indicates that the first version identifier has failed the data version verification, obtain the third object data and the second version identifier that matches the third object data from the above data storage node.

[0230] S4, perform the first data operation on the third object data to obtain the fourth object data, and send a second data write request carrying the fourth object data and the second version identifier to the data storage node.

[0231] Alternatively, as those skilled in the art will understand, Figure 13 The structure shown is for illustrative purposes only. Electronic devices can also be in-vehicle terminals, smartphones (such as Android phones, iOS phones, etc.), tablets, handheld computers, mobile internet devices (MIDs), PADs, and other terminal devices. Figure 13 This does not limit the structure of the aforementioned electronic devices. For example, the electronic device may also include components that are more... Figure 13 The more or fewer components shown (such as network interfaces, etc.), or having the same Figure 13 The different configurations shown.

[0232] The memory 1302 can be used to store software programs and modules, such as program instructions / modules corresponding to the object data processing method and apparatus in this embodiment of the invention. The processor 1304 executes various functional applications and data processing by running the software programs and modules stored in the memory 1302, thereby realizing the above-mentioned object data processing method. The memory 1302 may include high-speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory 1302 may further include memory remotely located relative to the processor 1304, and these remote memories can be connected to the terminal via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof. Specifically, the memory 1302 may be used, but is not limited to, for storing file information such as target logical files. As an example, such as Figure 13As shown, the memory 1302 may include, but is not limited to, the operation unit 1202, the first sending unit 1204, the acquisition unit 1206, and the second sending unit 1208 in the object data processing device. Furthermore, it may include, but is not limited to, other module units in the object data processing device, which will not be described further in this example.

[0233] Optionally, the transmission device 1306 described above is used to receive or send data via a network. Specific examples of the network described above may include wired networks and wireless networks. In one example, the transmission device 1306 includes a Network Interface Controller (NIC), which can be connected to other network devices and a router via a network cable to communicate with the Internet or a local area network. In another example, the transmission device 1306 is a Radio Frequency (RF) module, used for wireless communication with the Internet.

[0234] In addition, the above-mentioned electronic device also includes a display 1308 and a connection bus 1310 for connecting the various module components in the above-mentioned electronic device.

[0235] In other embodiments, the aforementioned terminal device or server can be a node in a distributed system, wherein the distributed system can be a blockchain system, which is a distributed system formed by connecting multiple nodes through network communication. The nodes can form a peer-to-peer network, and any form of computing device, such as a server, terminal, or other electronic device, can become a node in the blockchain system by joining this peer-to-peer network.

[0236] According to one aspect of this application, a computer program product is provided, comprising a computer program / instructions containing program code for performing the methods shown in the flowchart. In such embodiments, the computer program can be downloaded and installed from a network via a communication component, and / or installed from a removable medium. When the computer program is executed by a central processing unit, it performs various functions provided in embodiments of this application.

[0237] The sequence numbers of the above embodiments of the present invention are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0238] According to one aspect of this application, a computer-readable storage medium is provided, wherein a processor of a computer device reads computer instructions from the computer-readable storage medium, and the processor executes the computer instructions, causing the computer device to perform the aforementioned method for processing object data.

[0239] Optionally, in this embodiment, the computer-readable storage medium may be configured to store a computer program for performing the following steps:

[0240] S1, upon receiving a data operation request from the target client, performs a first data operation on the cached first object data to obtain the second object data;

[0241] S2, a first data write request is sent to the data storage node, wherein the first data write request carries the second object data and a first version identifier matching the first object data, and the data storage node is used to verify the multiple data write requests and perform a write operation on the object data according to the verification result, wherein the multiple data write requests include the first data write request.

[0242] S3, if the write verification result returned by the above data storage node indicates that the first version identifier has failed the data version verification, obtain the third object data and the second version identifier that matches the third object data from the above data storage node.

[0243] S4, perform the first data operation on the third object data to obtain the fourth object data, and send a second data write request carrying the fourth object data and the second version identifier to the data storage node.

[0244] Optionally, in this embodiment, those skilled in the art will understand that all or part of the steps in the various methods of the above embodiments can be implemented by a program instructing the hardware related to the terminal device. The program can be stored in a computer-readable storage medium, which may include: flash drive, read-only memory (ROM), random access memory (RAM), disk or optical disk, etc.

[0245] If the integrated units in the above embodiments are implemented as software functional units and sold or used as independent products, they can be stored in the aforementioned computer-readable storage medium. Based on this understanding, the technical solution of the present invention, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause one or more computer devices (which may be personal computers, servers, or network devices, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention.

[0246] In the above embodiments of the present invention, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0247] In the several embodiments provided in this application, it should be understood that the disclosed client can be implemented in other ways. The device embodiments described above are merely illustrative; for example, the division of units described above is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces, indirect coupling or communication connection between units or modules, and may be electrical or other forms.

[0248] The units described above as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0249] Furthermore, the functional units in the various embodiments of the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0250] The above description is only a preferred embodiment of the present invention. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of the present invention, and these improvements and modifications should also be considered within the scope of protection of the present invention.

Claims

1. A method of processing object data, characterized by, include: Upon receiving a data operation request from the target client, a first data operation is performed on the cached first object data to obtain second object data, wherein the first object data is used to describe the target data object corresponding to the data operation request; A first data write request is sent to a data storage node, wherein the first data write request carries the second object data and a first version identifier matching the first object data. The data storage node is used to verify multiple data write requests and perform a write operation on the object data according to the verification result. The multiple data write requests include the first data write request. If the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification, the third object data and the second version identifier that matches the third object data are obtained from the data storage node. The third object data is the object data currently written in the data storage node that describes the target data object. Perform the first data operation on the third object data to obtain the fourth object data, and send a second data write request carrying the fourth object data and the second version identifier to the data storage node.

2. The method of claim 1, wherein, The step of performing the first data operation on the third object data to obtain the fourth object data includes: Obtain an operation instruction list, wherein the operation instruction list is used to store data operation instructions that match at least one of the data operation requests; Retrieve the first data operation instruction from the list of operation instructions; The first data operation is performed on the third object data according to the first data operation instruction to obtain the fourth object data.

3. The method of claim 2, wherein, Upon receiving a data operation request from the target client, performing a first data operation on the cached first object data to obtain the second object data includes: According to the data operation request, retrieve the first object data corresponding to the data operation request from the cached data; Parse the data operation request to obtain the first data operation instruction that matches the data operation request; The first data operation instruction is stored in the operation instruction list, and the first data operation is performed on the first object data according to the first data operation instruction to obtain the second object data.

4. The method of claim 2, wherein, After sending a second data write request carrying the fourth object data and the second version identifier to the data storage node, the method further includes: Receive the write verification result returned by the data storage node; If the write verification result indicates that the second version identifier has passed the data version verification, the first data operation instruction is searched in the operation instruction list; In response to finding the first data operation instruction, the first data operation instruction is deleted from the operation instruction list.

5. The method of claim 2, wherein, If the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification, after obtaining the third object data and the second version identifier matching the third object data from the data storage node, the process further includes: Obtain the operation verification result that matches the first data operation; If the operation verification result indicates that the second object data obtained from the first data operation has not been written to the data storage node, it is determined that the first data operation will be performed on the third object data. If the operation verification result indicates that the second object data obtained from the first data operation has been written to the data storage node, the first data operation instruction is deleted from the operation instruction list.

6. The method of claim 5, wherein, The step of obtaining the operation verification result matching the first data operation includes: Obtain an operation identifier list, wherein the operation identifiers in the operation identifier list are used to indicate historical data operations, and the object data corresponding to the historical data operations has been written to the data storage node; If a data operation identifier indicating the first data operation is found in the operation identifier list, it is determined that the second object data obtained from the first data operation has been written to the data storage node.

7. The method of claim 5, wherein, The step of obtaining the operation verification result matching the first data operation includes one of the following: According to the operation identifier list stored locally, the operation verification result matching the first data operation is obtained, wherein the operation identifier in the operation identifier list is used to indicate historical data operations, and the object data corresponding to the historical data operations has been written to the data storage node. The operation verification result matching the first data operation is obtained from the data storage node, wherein the data storage node stores a list of operation identifiers for verifying data operations.

8. The method of claim 2, wherein, Before retrieving the third object data and the second version identifier matching the third object data from the data storage node, if the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification, the method further includes: If no write verification result is received from the data storage node within the target period, a third data write request is sent to the data storage node, wherein the third data write request carries the second object data and the first version identifier that matches the first object data.

9. The method of claim 1, wherein, After sending a second data write request carrying the fourth object data and the second version identifier to the data storage node, the method further includes: If the write verification result returned by the data storage node indicates that the second version identifier has passed the data version verification, it is determined that the fourth object data has been written to the data storage node; Send a data update command to at least one reference server and return the data operation result to the target client.

10. The method of claim 9, wherein, Sending a data update instruction to at least one reference server includes at least one of the following: Send a first data update instruction to at least one of the reference servers, wherein the first data update instruction is used to instruct at least one reference server to obtain updated object data and a data version identifier corresponding to the updated object data from the data storage node; A second data update instruction is sent to at least one of the reference servers, wherein the data update instruction carries the fourth object data and the second version identifier.

11. The method of claim 1, wherein, After sending the first data write request to the data storage node, the method further includes: If the write verification result returned by the data storage node indicates that the first version identifier has passed the data version verification, it is determined that the second object data has been written to the data storage node; Obtain a third version identifier that matches the second object data from the data storage node; Send a data update command to at least one reference server and return the data operation result to the target client.

12. The method of claim 1, wherein, Before performing the first data operation on the cached first object data to obtain the second object data, it also includes one of the following: Identify the resource object that matches the data operation request; retrieve the first object data describing the resource object from the cached data; A set of resource objects matching the data operation request is determined, wherein the set of resource objects includes multiple subsets of resource objects, and the resource objects in one subset of resource objects have the same resource attributes; a target subset of resource objects is determined from the multiple subsets of resource objects, and the first object data describing the target subset of resource objects is obtained from the cached data.

13. An apparatus for processing object data, characterized by include: An operation unit is configured to perform a first data operation on cached first object data to obtain second object data upon receiving a data operation request from a target client, wherein the first object data is used to describe the target data object corresponding to the data operation request; The first sending unit is configured to send a first data write request to a data storage node, wherein the first data write request carries the second object data and a first version identifier matching the first object data, and the data storage node is configured to verify multiple data write requests and perform a write operation on the object data according to the verification result, wherein the multiple data write requests include the first data write request. The acquisition unit is configured to acquire third object data and a second version identifier that matches the third object data from the data storage node when the write verification result returned by the data storage node indicates that the first version identifier has failed the data version verification. The third object data is object data currently written in the data storage node that describes the target data object. The second sending unit is used to perform the first data operation on the third object data to obtain the fourth object data, and send a second data write request carrying the fourth object data and the second version identifier to the data storage node.

14. A computer readable storage medium, characterized in that, The computer-readable storage medium includes a stored program, wherein the program, when executed, performs the method described in any one of claims 1 to 12.

15. A computer program product comprising computer programs / instructions, characterized in that, When the computer program / instructions are executed by the processor, they implement the steps of the method described in any one of claims 1 to 12.

16. An electronic device comprising a memory and a processor, characterized in that The memory stores a computer program, and the processor is configured to execute the method described in any one of claims 1 to 12 through the computer program.

Images