A data updating method and system capable of instant response

Abstract

The present application provides a data update method and device that can respond instantly. Among them, the method is to set up a local server LocalServer module including the same business code for the client and the server, and update the data between the client and the server through Command instructions. When the user performs a data update operation, the business logic is executed locally on the client, achieving an instant response and providing a good user experience. At the same time, the LocalServer module adopts an inert update method for the automatic update logic over time. On the server side, according to the time when the operation occurred and the business logic of the LocalServer module, the data object is directly deduced to the current time when the operation occurred, thereby pushing the data to the same state as the client, achieving consistency in data updates. At the same time, since the server and the client share the business logic code, it also reduces the development communication cost and avoids the generation of a large amount of redundant code.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to a data updating method, system, computing device and computer-readable storage medium capable of instant response. Background Art

[0002] In the traditional C / S architecture, most of the data update logic is processed on the server side. After the client performs related operations, it needs to wait for the server to return the processing results. Therefore, for some businesses that require frequent operations on the client side, such as game players frequently modifying the appearance of the character, the properties of props, and accepting tasks, high requirements are placed on the bandwidth and server performance. As a result, in many cases, the client does not receive the response results in a timely manner, which greatly affects the user experience.

[0003] In the prior art, in order to enable the client to make an immediate response, a code similar to that on the server side is implemented on the client application to complete the response, but this usually leads to data inconsistency and code redundancy. Summary of the invention

[0004] In view of this, the embodiments of the present application provide a data update method, system, computing device and computer-readable storage medium that can respond in a timely manner to solve the technical defects existing in the prior art.

[0005] According to a first aspect of an embodiment of the present application, a data update method capable of timely response is provided, comprising:

[0006] A local server LocalServer module is set on the client and the server; the business logic codes of the LocalServer modules of the client and the server are consistent;

[0007] When the user performs a data update operation, the client sends a Command instruction to the LocalServer module of the client and the server, and the Command instruction contains the data update logic;

[0008] The client LocalServer module executes the data update logic in the Command instruction and notifies the client display layer;

[0009] The server LocalServer module executes the data update logic in the Command instruction and returns the result to the client;

[0010] The client verifies the result returned by the server and executes subsequent instructions based on the verification result.

[0011] According to a second aspect of an embodiment of the present application, a data update system capable of timely response is provided, including:

[0012] The system includes a client, a server and a local server LocalServer arranged on the client and the server, and is used to execute the data updating method capable of timely response.

[0013] According to a third aspect of an embodiment of the present application, a computing device is provided, comprising a memory, a processor, and computer instructions stored in the memory and executable on the processor, wherein the processor implements the steps of the data update method capable of timely response when executing the instructions.

[0014] According to a fourth aspect of an embodiment of the present application, a computer-readable storage medium is provided, which stores computer instructions, and when the instructions are executed by a processor, the steps of the data update method that can respond in a timely manner are implemented.

[0015] In an embodiment of the present application, a local server LocalServer module including the same business code is set for the client and the server. When the user performs a data update operation, the business logic can be executed locally on the client. Therefore, frequently executed operations do not need to wait for server feedback, which provides a good user experience. For the automatic update logic over time, the server timer is transferred to the client through lazy update. On the server side, according to the operation occurrence time in the Command instruction and the business logic of LocalServer, the data object is directly deduced to the current operation occurrence time, thereby pushing the data object to the same state as the client, achieving data consistency. At the same time, the server and the client share business logic code, which reduces development communication costs and avoids the generation of a large amount of redundant code. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] Figure 1 is a structural block diagram of a computing device provided in an embodiment of the present application;

[0017] Figure 2 It is a flow chart of a data updating method capable of instant response provided by an embodiment of the present application;

[0018] Figure 3 It is a structural diagram of a data update system capable of instant response provided by an embodiment of the present application;

[0019] Figure 4 It is a structural diagram of a Command instruction for implementing data update logic provided in an embodiment of the present application; DETAILED DESCRIPTION

[0020] Many specific details are described in the following description to facilitate a full understanding of the present application. However, the present application can be implemented in many other ways than those described herein, and those skilled in the art can make similar generalizations without violating the connotation of the present application, so the present application is not limited by the specific implementation disclosed below.

[0021] The terms used in one or more embodiments of the present application are only for the purpose of describing specific embodiments, and are not intended to limit one or more embodiments of the present application. The singular forms of "a", "said" and "the" used in one or more embodiments of the present application and the appended claims are also intended to include plural forms, unless the context clearly indicates other meanings. It should also be understood that the term "and / or" used in one or more embodiments of the present application refers to and includes any or all possible combinations of one or more associated listed items.

[0022] It should be understood that, although the terms first, second, etc. may be used to describe various information in one or more embodiments of the present application, these information should not be limited to these terms. These terms are only used to distinguish the same type of information from each other. For example, without departing from the scope of one or more embodiments of the present application, the first may also be referred to as the second, and similarly, the second may also be referred to as the first. Depending on the context, the word "if" as used herein may be interpreted as "in response to determination".

[0023] In the present application, a data update method, system, computing device and computer-readable storage medium capable of instant response are provided, which are described in detail one by one in the following embodiments.

[0024] Figure 1 The structure block diagram of a computing device 100 according to an embodiment of the present application is shown. The components of the computing device 100 include but are not limited to a memory 110 and a processor 120. The processor 120 is connected to the memory 110 via a bus 130, and the database 150 is used to store data.

[0025] The computing device 100 also includes an access device 140 that enables the computing device 100 to communicate via one or more networks 160. Examples of these networks include a public switched telephone network (PSTN), a local area network (LAN), a wide area network (WAN), a personal area network (PAN), or a combination of communication networks such as the Internet. The access device 140 may include one or more of any type of network interface (e.g., a network interface card (NIC)) whether wired or wireless, such as an IEEE 802.11 wireless local area network (WLAN) wireless interface, a World Wide Interoperability for Microwave Access (Wi-MAX) interface, an Ethernet interface, a universal serial bus (USB) interface, a cellular network interface, a Bluetooth interface, a near field communication (NFC) interface, and the like.

[0026] In one embodiment of the present application, the above components of the computing device 100 and Figure 1 Other components not shown in the figure may also be connected to each other, for example, via a bus. It should be understood that Figure 1 The computing device structure block diagram shown is only for the purpose of illustration, and is not intended to limit the scope of the present application. Those skilled in the art may add or replace other components as needed.

[0027] Computing device 100 may be any type of stationary or mobile computing device, including a mobile computer or mobile computing device (e.g., a tablet computer, a personal digital assistant, a laptop computer, a notebook computer, a netbook, etc.), a mobile phone (e.g., a smartphone), a wearable computing device (e.g., a smart watch, smart glasses, etc.), or other type of mobile device, or a stationary computing device such as a desktop computer or PC.

[0028] The computing device 100 may also be a mobile or stationary server.

[0029] The processor 120 may execute Figure 2 The steps in the data update method that can respond instantly are shown. Figure 2 A flow chart of a data update method capable of instant response according to an embodiment of the present application is shown, including steps 202 to 210.

[0030] Step S202: Setting a local server LocalServer module on the client and the server, wherein the business logic codes of the LocalServer modules of the client and the server are consistent;

[0031] In the prior art, in order to achieve instant response of the client, a set of codes similar to those on the server side is implemented in the client program to imitate the server response. However, due to the differences in programming languages ​​and implementation methods used by the client and server programs, the generated data will be inconsistent. At the same time, this method also causes code redundancy and reduces development efficiency.

[0032] Therefore, in the implementation of the present application, a local LocalServer module is set for the client and the server respectively, and the code of the LocalServer module is consistent. The module is set on both the client and the server. Since the implementation code is the same, the problem of inconsistent processing logic and generated data between the client and the server program is solved, and there is no code redundancy problem caused by multiple development.

[0033] Step S204: When the user performs a data update operation, the client generates a Command instruction according to the operation and sends it to the LocalServer module of the client and the server;

[0034] In a specific implementation, when the user performs a data update operation, the client generates a Command instruction according to relevant data, and sends the Command instruction including the data update logic to the client and the LocalServer module of the server.

[0035] Furthermore, the Command instruction contains data update logic including the time when the user operation occurs, the data object data and other parameters. Any data change operation can only be performed through the Command instruction.

[0036] Step S206: After receiving the Command instruction, the LocalServer module of the client executes the data update logic in the Command instruction and notifies the client display layer;

[0037] In a specific implementation, the LocalServer module of the client receives an operation instruction sent by the client, such as an upgrade of a prop. The LocalServer module of the client updates the data object according to the Command instruction, and throws an event after completing the update to notify the display layer. Since the data update instruction issued by the client is executed by the LocalServer of the client, the execution speed is fast and an instant response can be achieved.

[0038] Step S208: After receiving the Command instruction, the LocalServer module of the server executes the data update logic in the Command instruction and returns the result to the client through the server;

[0039] When the server's LocalServer module receives the Command instruction, it deserializes and executes the data update logic in the Command instruction. After execution, the data result is returned to the server. The server performs data storage and distribution operations and returns the result to the client.

[0040] Step S210: The client verifies the result returned by the server and executes subsequent instructions according to the verification result.

[0041] In a specific implementation, for the client's local logic processing operation instructions, such as the upgrade of props, the server returns the processing result of LocalServer, and the client verifies the result. If an error occurs, exception handling is performed. If no error occurs, it means that the processing results of the server and the client are the same, and no other processing is required.

[0042] In another specific implementation, for operation instructions that must be implemented by the server, such as the results of summoning, the results of drawing a card, etc., these data must be processed and issued by the server; therefore, when the server receives such operation instructions sent by the client, the server LocalServer generates corresponding business data, such as the results of drawing a card, and returns it; the client verifies the business data, and after the verification passes, the client executes the corresponding data update logic based on the business data.

[0043] In the above implementation, LocalServer performs different functions according to different business logic requirements and feedback results, completing two different modes of logic processing.

[0044] According to a specific case implemented in the above embodiment, for example, when a game player upgrades a prop or draws a card, he will frequently click a button. If each operation needs to be confirmed by the server's feedback before it can be completed, it is unrealistic to achieve an immediate response or refresh on the client. Therefore, in this embodiment of the present application, every time a player clicks a button, the time of the operation and the relevant data are encapsulated into a Command instruction. The Command instruction is first executed on the local LocalServer of the client, completes the data update and notifies the display layer to refresh the display status of the prop. Since it is executed locally, the process can be completed instantly without waiting, and the user experience is good. At the same time, in order to maintain the data consistency between the client and the server, the Command instruction is also sent to the LocalServer of the server, and the same data update logic is also executed on the server side and the execution result is returned. The client verifies the returned result and performs exception handling if an error occurs. Since the LocalServer modules on the client and server sides are consistent in the business logic code, when executing this operation, not only an immediate response is achieved, but also redundant development at the code level is reduced, and the client development and debugging can also be independent of the server side.

[0045] In another embodiment of the present application, Figure 3 As shown, a data update system capable of instant feedback is implemented, which includes a client and a server and a local server LocalServer arranged on both.

[0046] In the game logic, the logic related to a single user includes not only active operations but also passive operations that are automatically executed. For example, game players will actively use props to increase the physical strength of the character. At the same time, the physical strength of the character will automatically decrease over time, for example, 10 points of physical strength will be reduced every 5 minutes. In the prior art, in order to achieve synchronization of similar data, some timers are usually set on the server. After the timer is triggered, the server will push the protocol to the client, and then the client will update the data. This undoubtedly makes the interaction between the client and the server frequent and increases the overhead of the entire system. In this embodiment of the present application, the LocalServer technology is used to transfer the timing logic to the client, which reduces the frequent operations between the client and the server, and will not cause the problem of the logic that needs to be triggered regularly not being triggered due to network problems.

[0047] Similarly, in this embodiment, a local server LocalServer module is set on the client and the server, and the codes of the LocalServer modules of the client and the server are consistent;

[0048] When the user performs a data update operation, the client generates a Command instruction based on the operation and sends it to the client LocalServer module for execution, where the data object can also contain automatic update logic;

[0049] In a specific scenario, the automatic update logic includes, for example, clicking on a building upgrade and automatically completing the upgrade after 10 seconds. If server timing is used, the server pushes the protocol to the client after the timer is triggered, and then the client updates the data, but this method will lead to frequent interactions between the client and the server. Therefore, in the embodiment of the present application, the timing function can be transferred to the client through the LocalServer technology, and the server no longer uses the timer, thereby reducing interactions.

[0050] In a specific implementation, an instance of the Command instruction includes the execution of the following functions:

[0051] Initialization function init()

[0052] Initialize the Command instruction according to the time time when the operation occurs, the data object data and other parameters.

[0053] StatusUpdate(time) function

[0054] This function is used to deduce the state of the data object to the current operation time.

[0055] In a specific implementation, the data object data is updated by the business logic of the system. When the data object is updated, the UpdateTime attribute of the data object needs to be updated to the latest time. When the next operation occurs, all update instructions occurring between the attribute UpdateTime of the data object and the operation occurrence time are obtained and executed. These update instructions are generated according to the business logic of the system.

[0056] In another specific implementation, the data object further includes automatic update logic.

[0057]

[0058] This function is used to obtain the automatic execution command autoCommand that occurs between the time LastAutoCommandUpdateTime when the last automatic update command autoCommand in the data object occurs and the time time when this operation occurs. If autoCommand exists, the update time UpdateTime and LastAutoCommandUpdateTime of the data object are updated and the autoCommand is executed, and then the loop continues until there is no autoCommand between the latest time and the latest time. In this way, the state of the data object is deduced to the latest time.

[0059] For example, the character's stamina decreases by 10 points every 5 minutes. The last time the stamina was automatically reduced in the data object data is 13:00. If the time of the current operation, such as using a prop, is 13:07, the character's stamina will be automatically reduced by 10 points first, and the character's LastAutoCommandUpdateTime will be updated to 13:05 and the character's UpdateTime will be updated to 13:07, and then the next cycle will be performed.

[0060] Furthermore, the StatusUpdate function is executed on the client through a timer to implement the execution of the automatic data update logic autoCommand, thereby driving the status of the client's data object to advance with time.

[0061] GetResultCode()

[0062] This function is used to determine whether the Command instruction is legal before updating the data. If it is illegal, the command will not be executed and an error code will be returned. Among them, the automatic command autoCommand does not need to be checked for legality because the automatic command is not actively triggered by the user.

[0063] The specific logic of the GetResultCode function is implemented according to the logic of the Command instruction itself. For example, the legitimacy check of the hero upgrade protocol includes whether there are enough resources, whether the hero exists, whether the hero has exceeded the current level limit, etc. This part of the code needs to be executed on the server at the same time, so the server requirements also need to be considered when implementing this function.

[0064] LocalUpdate()

[0065] The LocalUpdate function is responsible for executing specific business logic and updating data. When the StatusUpdate(time) function in the Command instruction deduces the state of the data object to the time when the current operation occurs, the LocalUpdate method executes the specific update logic included in the current operation. After the execution of this method, an event will be thrown, and the client display layer can listen to the event for immediate feedback.

[0066] In a specific implementation, the operation instructions are processed for the local logic of the client. For example, when the user uses a prop to increase the character's physical strength, the Command instruction first deduce the state of the character object to the time when the prop is clicked through the StatusUpdate function, and then uses the LocalUpdate function to execute the functional logic of the prop to increase the physical strength.

[0067] In another specific implementation, for operation instructions that must be implemented by the server, such as the result of summoning, the result of drawing a card, etc., these data must be processed and issued by the server. Therefore, in this implementation, the Command instruction only encapsulates the operation instruction and sends it to the server, and the server executes the corresponding business logic. In this case, the LocalUpdate() function in the Command instruction does not process any business logic.

[0068] ClientRequest() function

[0069] When the LocalUpdate function is executed successfully, the client sends the serialized Command instruction to the server through the ClientRequest function.

[0070] In the embodiment of the present application, the client determines the type of the Command instruction and only sends the Command instruction generated by the user's active operation to the server, and does not send the autoCommand instruction.

[0071] GetResponse() function

[0072] When the server returns the execution result to the client, the client verifies the result through the GetResponse function.

[0073] In a specific implementation, the client's local logic processes the operation instructions and verifies the processing results returned by the server. If an error occurs, exception handling is performed. If no error occurs, it means that the processing results of the server and the client are the same and no other processing is required.

[0074] In another specific implementation, for operation instructions that must be implemented by the server, such as the result of summoning, the result of drawing a card, etc., these data must be processed by the server, such as the server LocalServer generating the result of drawing a card. The GetResponse function verifies this type of return result, and if the verification passes, calls the RemoteUpdate function to execute the local data update logic of the client according to the return result.

[0075] RemoteUpdate() function

[0076] This function receives and executes the data returned by the server for the operation Command instruction that must be implemented by the server, implements the client's data update logic, and achieves data consistency between the client and the server.

[0077] Corresponding to the client, on the server side, after receiving the Command instruction sent by the client, the server forwards it to the LocalServer module of the server. The LocalServer module first deduce the data object to the time when the operation occurs.

[0078] Since the server does not have a timer and does not obtain the automatic update command autoCommand from the client, in order to maintain data consistency between the server and the client, the server LocalServer executes the StatusUpdate(time) function in the Command command and deduce the state of the data object to the time time when the operation in the Command command occurs.

[0079] In a specific implementation, the player used props to increase the stamina at 13:00 (the first operation) and 13:10 (the second operation). Assuming that the last time the stamina in the character object was automatically reduced, LastStaminaUpdateTime, is 12:59, the client's LocalServer will use the timer to obtain and execute two autoCommands for automatic stamina reduction at 13:04 and 13:09 as time goes by. As for the server, since it does not use a timer and cannot obtain the automatic commands on the client, when the server's LocalServer receives the Command command of the second operation (13:10), it will deduce the character to the latest state (13:10) according to the business processing logic. During the deduction process, the server learned from the first operation received that the last time the character object's stamina was automatically reduced was 12:59, and from the second operation received that the current operation occurred at 13:10. Therefore, the server directly subtracted 20 points of stamina based on the automatic update logic - "the character's stamina value decreases by 10 points every 5 minutes." Through this method, LocalServer first deduces the state of the character object from the previous operation time to the current operation time, and then starts to execute the specific business of the current operation, thereby ensuring data consistency between the client and the server.

[0080] In another specific implementation, the player upgrades 1 building and trains 10 soldiers. These two active operations occur at the 1st second and are completed at the 20th second. When the client timer reaches 20 seconds, these two operations will be automatically completed and the display layer will be notified. On the server side, there is no timer and the completion instruction on the client cannot be obtained. Therefore, the server does not update after receiving the upgrade request at the 1st second, and only stays in the state of the 1st second until the next request from the client is received. It is updated to the latest state. For example, when the client initiates a new request at the 200th second, the server's LocalServer will deduce the state of the data object from the 1st second to the 200th second, thereby completing the data synchronization work of the above upgrade operation on the database side.

[0081] In the above implementation, for the automatic update logic that often appears in the game scene, the server timer is transferred to the client through lazy update. When the client executes the relevant automatic update logic, it can be completed using the local timer and LocalServer without interacting with the server, which improves the response speed and efficiency of the application. On the server side, LocalServer directly deduce the data object to the current operation time according to the operation time and business logic in the Command instruction, thereby pushing the data to the same state as the client and achieving data consistency.

[0082] In one embodiment of the present application, a computing device is also provided, including a memory, a processor, and computer instructions stored in the memory and executable on the processor, wherein the processor implements the steps of the data update method capable of instant response when executing the instructions.

[0083] The above is a schematic scheme of a computing device of this embodiment. It should be noted that the technical scheme of the computing device and the technical scheme of the above-mentioned data update method capable of instant response belong to the same concept, and the details not described in detail in the technical scheme of the computing device can be referred to the description of the technical scheme of the above-mentioned data update method capable of instant response.

[0084] An embodiment of the present application further provides a computer-readable storage medium storing computer instructions, which, when executed by a processor, implement the steps of the data update method capable of instant response as described above.

[0085] The above is a schematic scheme of a computer-readable storage medium of this embodiment. It should be noted that the technical scheme of the storage medium and the technical scheme of the above-mentioned data update method capable of instant response belong to the same concept, and the details not described in detail in the technical scheme of the storage medium can be referred to the description of the technical scheme of the above-mentioned data update method capable of instant response.

[0086] The above describes specific embodiments of the present application. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recorded in the claims can be performed in an order different from that in the embodiments and still achieve the desired results. In addition, the processes depicted in the accompanying drawings do not necessarily require the specific order or continuous order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0087] The computer instructions include computer program codes, which may be in source code form, object code form, executable files or some intermediate forms, etc. The computer-readable medium may include: any entity or device capable of carrying the computer program code, recording medium, USB flash drive, mobile hard disk, magnetic disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electric carrier signal, telecommunication signal and software distribution medium, etc. It should be noted that the content contained in the computer-readable medium may be appropriately increased or decreased according to the requirements of legislation and patent practice in the jurisdiction. For example, in some jurisdictions, according to legislation and patent practice, computer-readable media do not include electric carrier signals and telecommunication signals.

[0088] It should be noted that, for the above-mentioned method embodiments, for the sake of simplicity of description, they are all expressed as a series of action combinations, but those skilled in the art should be aware that the present application is not limited by the described action sequence, because according to the present application, certain steps can be performed in other sequences or simultaneously. Secondly, those skilled in the art should also be aware that the embodiments described in the specification are all preferred embodiments, and the actions and modules involved are not necessarily required by the present application.

[0089] In the above embodiments, the description of each embodiment has its own emphasis. For parts that are not described in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0090] The preferred embodiments of the present application disclosed above are only used to help explain the present application. The optional embodiments do not describe all the details in detail, nor do they limit the invention to the specific implementation methods described. Obviously, many modifications and changes can be made according to the content of the present application. The present application selects and specifically describes these embodiments in order to better explain the principles and practical applications of the present application, so that those skilled in the art can understand and use the present application well. The present application is only limited by the claims and their full scope and equivalents.

Claims

1. A data updating method capable of instant response, characterized in that: include: Set up the local server LocalServer module on the client and server; The business logic code of the LocalServer module of the client and the server is consistent; When the user performs a data update operation, the client sends a Command instruction to the LocalServer module of the client and the server. The Command instruction includes data update logic and also includes: Execute the initialization function init(), which is used to initialize the Command instruction according to the operation time, data object and other parameters; Execute the data object status update function StatusUpdate(time), which is used to deduce the status of the data object to the time when the operation occurs; wherein, deducing the status of the data object to the time when the operation occurs includes: the client LocalServer obtains all update instructions that occur between the time when the data in the data object last changed and the time when the operation occurs, and executes them in sequence; the server LocalServer obtains the attributes of the data object in the last operation request and the current operation request, and directly deduce the status of the data object to the time when the current operation occurs according to the business logic; Execute the data update function LocalUpdate(), which is used to execute the data update operation triggered by the client; The client LocalServer module executes the data update logic in the Command instruction and notifies the client display layer; The server LocalServer module executes the data update logic in the Command instruction and returns the update result to the client through the server; The client verifies the result returned by the server and executes subsequent instructions based on the verification result.

2. The method according to claim 1, wherein: The client LocalServer obtains all update instructions occurring between the time when the data in the data object last changed and the time when the operation occurred, including: Obtain all automatic update instructions that occur between the time when the last automatic update instruction occurs in the data object and the time when the operation occurs; The automatic update instruction is executed periodically according to the setting of the client timer.

3. The method according to claim 2, wherein: The Command instruction also includes: Execute the client request function ClientRequest(), which is used to send the serialized Command instruction to the server when the data update function LocalUpdate() is successfully executed.

4. The method according to claim 1, wherein: The client verifies the result returned by the server, and executes subsequent instructions according to the verification result, including: If the Command instruction is a client local logic processing instruction, the client verifies the result returned by the server, and performs exception processing if an error occurs. If no error occurs, no other processing is required.

5. The method according to claim 1, wherein: The client verifies the result returned by the server, and executes subsequent instructions according to the verification result, which further includes: If the Command instruction is an instruction that must be implemented by the server, the client verifies the service data returned by the server, and executes the data update operation according to the service data after the verification passes.

6. The method according to claim 2, wherein: The Command instruction also includes: The remote update function RemoteUpdate() is used to perform data update operations on the client according to the business data returned by the server.

7. A data updating system capable of instant response, characterized in that: The system includes a client, a server, and a local server LocalServer arranged on the client and the server, and is used to execute the method according to any one of claims 1-6.

8. A computing device comprising a memory, a processor, and computer instructions stored in the memory and executable on the processor, characterized in that: When the processor executes the instructions, the steps of the method according to any one of claims 1 to 6 are implemented.

9. A computer-readable storage medium storing computer instructions, characterized in that: When the instruction is executed by a processor, the steps of the method according to any one of claims 1 to 6 are implemented.

Images