CN115334163A

CN115334163A - Service data processing method and device and server

Info

Publication number: CN115334163A
Application number: CN202210954429.9A
Authority: CN
Inventors: 姚正宇; 张兴伟; 马辉; 沈晓煌
Original assignee: Industrial and Commercial Bank of China Ltd ICBC
Current assignee: Industrial and Commercial Bank of China Ltd ICBC
Priority date: 2022-08-10
Filing date: 2022-08-10
Publication date: 2022-11-11

Abstract

The specification provides a service data processing method, a service data processing device and a server, and is applied to the field of big data. Based on the method, the server which is newly jointed with the target terminal in the service processing system can effectively acquire and utilize the target session data which is existed in the interaction process which is not finished last time with the service processing system by the target terminal, and directly process the subsequent service data without repeating the interaction process which is existed in the interaction process last time by the target user, thereby improving the overall processing efficiency, shortening the waiting time of the target user and leading the target user to obtain relatively better interaction experience; meanwhile, as the shared cache database is additionally introduced and used in the service processing system to cache the session data of each server in the cluster, the local storage burden of the servers is effectively reduced.

Description

Service data processing method and device and server

Technical Field

The present specification belongs to the field of big data technologies, and in particular, to a service data processing method, apparatus, and server.

Background

In the field of big data technology, a service processing system responsible for service data processing often includes a plurality of servers. Generally, when a user needs to perform service data processing through a service processing system, the service processing system allocates one of the servers to interface with the user. The server can firstly carry out data interaction related to the service with the user to obtain the required session data; and then according to the session data, carrying out specific service data processing.

However, during the data interaction between the server and the user, sometimes the interaction between the user and the server is interrupted due to reasons such as network interruption. When the user reconnects to the business processing system, the business processing system may assign a new server to interface with the user. At this time, based on the existing method, the new server needs to interact with the user again to acquire the session data again, so as to perform subsequent service data processing. Thus, the user needs to repeat the interaction process that has been performed before; meanwhile, the waiting time of the user is prolonged, and the interactive experience of the user is influenced.

In view of the above problems, no effective solution has been proposed.

Disclosure of Invention

The present specification provides a service data processing method, a device and a server, which can improve the overall processing efficiency, shorten the waiting time of a target user, and enable the target user to obtain relatively good interactive experience; on the other hand, the local storage burden of the server can be effectively relieved.

The present specification provides a service data processing method, which is applied to a server in a service processing system, where the service processing system includes a server cluster and a shared cache database, and the method includes:

receiving a target service data processing request initiated by a target terminal;

detecting whether a target service data processing request carries a target session identifier or not; the target session identifier is used for indicating target session data in the last unfinished interactive process of the target terminal and the service processing system;

under the condition that the target service data processing request is determined to carry the target session identifier, inquiring a local session data record according to the target session identifier;

under the condition that the target session identification does not exist in the local session data record, session data synchronization is carried out through the shared cache database according to a preset synchronization rule, and the synchronized local session data record is obtained;

and performing corresponding service data processing according to the synchronized local session data record.

In one embodiment, the local session data record contains one or more session data; wherein the session data respectively correspond to a session identifier.

In one embodiment, the session data further includes a session time.

In one embodiment, in the process of processing the target service data processing request according to the synchronized local session data record, the method further includes: and storing the related session data involved in the processing process into a local session data record according to the target session identifier.

In one embodiment, the method further comprises:

detecting whether first invalid session data with the storage time exceeding a first effective duration exists in a current local session data record or not at each preset first time interval according to the session time of the session data;

and in the case that the first failure session data exists in the current local session data record, deleting the first failure session data from the current local session data record.

In one embodiment, the method further comprises:

and uploading the current local session data record to the shared cache database at a preset second time interval so as to update the session data stored in the shared cache database.

In one embodiment, while uploading the current local session data record to the shared cache database, the method further comprises:

accessing the shared cache database, and detecting whether second invalid session data with the storage time exceeding a second effective duration exists in the current shared cache database according to the session time of the session data;

and under the condition that the second failure session data exist in the current shared cache database, deleting the second failure session data from the current shared cache database.

In one embodiment, the session data further carries a status tag for indicating whether the interaction process is finished.

In one embodiment, the method further comprises:

and uploading the session data with the status label of unfinished in the current local session data record to the shared cache database at a preset second time interval so as to update the session data stored in the shared cache database.

In an embodiment, after detecting whether the target service data processing request carries the target session identifier, the method further includes:

under the condition that the target service data processing request is determined not to carry the target session identifier, generating the target session identifier; and providing the target session identification to a target terminal;

interacting with a target terminal to acquire related session data; storing the session data in the local session data record according to the target session identifier;

and according to the session data, carrying out corresponding service data processing.

In one embodiment, after querying the local session data record based on the target session identification, the method further comprises:

and under the condition that the target session identification exists in the local session data record, performing corresponding service data processing according to the local session data record.

The present specification further provides a service data processing method, which is applied to a target terminal, and includes:

under the condition that the trigger operation initiated by the target user is detected, detecting whether the last interactive process with the service processing system is finished or not;

under the condition that the last interactive process with the service processing system is not finished, acquiring a target session identifier indicating target session data in the last interactive process;

responding to the trigger operation, and generating a target service data processing request carrying a target session identifier;

and sending the target service data processing request to a service processing system.

The present specification also provides a service data processing apparatus applied to a server in a service processing system, where the service processing system includes a server cluster and a shared cache database, and the apparatus includes:

the receiving module is used for receiving a target service data processing request initiated by a target terminal;

the detection module is used for detecting whether the target service data processing request carries a target session identifier or not; the target session identifier is used for indicating target session data in the last unfinished interactive process of the target terminal and the service processing system;

the query module is used for querying the local session data record according to the target session identifier under the condition that the target service data processing request is determined to carry the target session identifier;

the synchronization module is used for carrying out session data synchronization with the shared cache database according to a preset synchronization rule under the condition that the target session identifier does not exist in the local session data record, so as to obtain the synchronized local session data record;

and the processing module is used for carrying out corresponding service data processing according to the synchronized local session data record.

The present specification also provides a server comprising a processor and a memory for storing processor-executable instructions, wherein the processor executes the instructions to implement the relevant steps of the business data processing method.

The present specification also provides a computer readable storage medium having stored thereon computer instructions, which when executed by a processor, implement the relevant steps of the business data processing method.

Based on the service data processing method, device and server provided by the present specification, after receiving a target service data processing request initiated by a target user through a target terminal, a service processing system can distribute the target service data processing request to a server currently meeting requirements in a server cluster of the service processing system for processing. After receiving the target service data processing request, the server may first detect whether the target service data processing request carries a target session identifier; the target session identifier is used for indicating target session data in the last unfinished interactive process of the target terminal and the service processing system; under the condition that the target service data processing request is determined to carry the target session identifier, inquiring a local session data record according to the target session identifier; under the condition that the target session identification does not exist in the local session data record, session data synchronization is carried out through the local session data record and the shared cache database according to a preset synchronization rule, and the synchronized local session data record is obtained; and further, corresponding service data processing can be performed according to the synchronized local session data records. Therefore, a server which is newly butted with the target terminal in the service processing system can completely acquire and utilize target session data which is existed in the last unfinished interaction process of the target terminal and the service processing system, and corresponding service data processing is continuously carried out based on the last unfinished interaction process, so that the target user does not need to repeat the interaction flow which is already carried out in the last interaction process, the integral processing efficiency is improved, the waiting time of the target user is shortened, and the target user can obtain relatively good interaction experience; meanwhile, as the shared cache database is additionally introduced and used in the service processing system to cache the session data of each server, the local storage burden of the servers can be effectively reduced.

Drawings

In order to more clearly illustrate the embodiments of the present specification, the drawings needed to be used in the embodiments will be briefly described below, and the drawings in the following description are only some of the embodiments described in the specification, and it is obvious to those skilled in the art that other drawings can be obtained based on the drawings without any inventive work.

Fig. 1 is a schematic flow chart of a service data processing method provided in an embodiment of the present specification;

fig. 2 is a schematic diagram of an embodiment of a service data processing method provided in this specification, in an example scenario;

fig. 3 is a schematic diagram of an embodiment of a service data processing method provided by an embodiment of the present specification, in a scenario example;

fig. 4 is a schematic diagram of an embodiment of a service data processing method provided by an embodiment of the present specification, in a scenario example;

fig. 5 is a flowchart illustrating a service data processing method according to an embodiment of the present specification;

FIG. 6 is a schematic structural component diagram of a server provided in an embodiment of the present description;

fig. 7 is a schematic structural composition diagram of a service data processing apparatus provided in an embodiment of the present specification;

fig. 8 is a schematic structural component diagram of a service data processing apparatus according to an embodiment of the present specification.

Detailed Description

In order to make those skilled in the art better understand the technical solutions in the present specification, the technical solutions in the embodiments of the present specification will be clearly and completely described below with reference to the drawings in the embodiments of the present specification, and it is obvious that the described embodiments are only a part of the embodiments of the present specification, and not all of the embodiments. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments in the present specification without making any creative effort shall fall within the protection scope of the present specification.

Referring to fig. 1, an embodiment of the present specification provides a service data processing method, where the method is specifically applied to a server side in a service processing system, where the service processing system includes a server cluster and a shared cache database. In specific implementation, the method may include the following:

s101: receiving a target service data processing request initiated by a target terminal;

s102: detecting whether the target service data processing request carries a target session identifier or not; the target session identifier is used for indicating target session data in the last unfinished interactive process of the target terminal and the service processing system;

s103: under the condition that the target service data processing request is determined to carry the target session identifier, inquiring a local session data record according to the target session identifier;

s104: under the condition that the target session identification does not exist in the local session data record, session data synchronization is carried out through the shared cache database according to a preset synchronization rule, and the synchronized local session data record is obtained;

s105: and performing corresponding service data processing according to the synchronized local session data record.

Based on the embodiment, the server newly butted with the target terminal in the service processing system can completely acquire and utilize the target session data existing in the last unfinished interactive process of the target terminal and the service processing system, and continue to process the corresponding service data based on the last unfinished interactive process, so that the target user does not need to repeat the interactive flow already carried out in the last interactive process, the overall processing efficiency is improved, the waiting time of the target user is shortened, and the target user can obtain relatively better interactive experience; meanwhile, as the shared cache database is additionally introduced and used in the service processing system to cache the session data of each server, the local storage burden of the servers is effectively reduced.

In some embodiments, see in particular fig. 2. The service processing system at least comprises a server cluster and a shared cache database (or cache device). The server cluster may specifically include a plurality of servers (or distributed nodes), for example, a first server, a second server, a third server … … nth server, and the like. Each of the plurality of servers may be connected to the shared cache database in a wired or wireless manner to collectively manage and maintain the shared cache database. The shared cache database can be used for caching session data generated by a user in an interaction process with a service processing system. Local session data records (a cache device local to the server, for example, local session data) with a relatively small storage amount are also configured locally at each of the plurality of servers, and are used for caching session data generated by the server during interaction with the docked user.

Further, referring to fig. 2, the service processing system further includes a routing module (or gateway module). Specifically, when a target user initiates a target service data processing request to a service processing system through a held target terminal, the target service data processing request will reach the routing module first. The routing module determines a current server meeting the requirements (for example, a server with the current remaining available processing resource amount larger than a preset safe resource amount threshold) according to the running state of each server in the current server cluster; and distribute the target service data processing request to the server (e.g., the first server) for processing. Correspondingly, the first server in the service processing system can be specifically butted with the target terminal subsequently, the first server performs related data interaction with the target terminal, and after the required complete session data are obtained, specific service data processing is completed according to the session data.

The server may specifically include a background server applied to one side of the service processing system and capable of implementing functions such as data transmission and data processing. Specifically, the server may be, for example, an electronic device having data operation, storage function and network interaction function. Alternatively, the server may be a software program running in the electronic device and providing support for data processing, storage and network interaction. In the present embodiment, the number of servers is not particularly limited. The server may specifically be one server, or may also be several servers, or a server cluster formed by several servers.

The target terminal may specifically include a front end that is applied to a target user side and is capable of implementing functions such as data acquisition and data transmission. Specifically, the target terminal may be, for example, an electronic device such as a desktop computer, a tablet computer, a notebook computer, and a smart phone. Alternatively, the target terminal may be a software application capable of running in the electronic device. For example, it may be some APP running on a smartphone, etc.

During the relevant data interaction between the first server and the target terminal, the interaction process may be suddenly interrupted before the end due to some reasons (for example, the network signal of the target terminal is poor, IP drift occurs, and the like). In this case, when the target terminal re-sends the target service data processing request and re-connects to the service processing system, the routing module will re-determine a new server (e.g., a second server) from the server cluster to interface with the target terminal.

Based on the existing method, the server which is docked with the target terminal after the interaction is interrupted is changed into the second server, the second server does not interact with the target terminal before, and session data obtained in the previous interaction process is not cached in the local part of the second server. Under the circumstance, the second server needs to start interacting with the target terminal again to acquire the required session data again, so that the waiting time of the target user is increased, and the interaction experience of the target user is influenced.

Based on the method, when the target terminal re-accesses the service system, the re-sent target service data processing request can carry the target session identifier of the target session data in the last unfinished interactive process. After the target terminal is in butt joint, the second server can detect the local session data record according to the target session identifier; under the condition that the local session data record is determined not to have the target session identifier and not to cache related target session data, session data synchronization can be carried out through the local session data record and the shared cache data, so that the synchronized local session data record is obtained; further, target service data existing in the previous interaction process of the target terminal and the first server can be obtained according to the synchronized local session data record; further, the data interaction which is not finished between the target terminal and the first server before can be continued based on the target service data as the interaction starting point. Therefore, the target user does not need to repeat the interaction process which is already carried out in the last interaction process, the waiting time of the target user is shortened, and the target user can obtain relatively good interaction experience.

In some embodiments, the service data processing requests may include different types of service data processing requests corresponding to different application scenarios, and accordingly, the involved data interaction processes may also include different types of interaction processes, the involved session data, and the final service data processing may include different types of session data and different types of service data processing.

Specifically, for example, the target service data processing request may specifically include an account registration request. Accordingly, the involved data interaction processes may include an interaction process of the identity information of the user (e.g., an interaction process of determining the name of the user, the account name), an interaction process of the user's custom data (e.g., an interaction process of determining the interest, hobbies, and personality tags of the user), and the like. Accordingly, the required session data may include the identity information of the user determined through the interactive process of the identity information, the user's custom data determined through the interactive process of the definition data, and the like. The service data processing may specifically include account registration processing of the target user.

For another example, the target service data processing request may further include a transaction request. Accordingly, the involved data interaction processes may include an interaction process of a payment order of the user (e.g., an interaction process of determining a commodity object purchased by the user, a purchase price and a purchase quantity of the commodity object), an interaction process of payment verification of the user (e.g., an interaction process of receiving a confirmation payment instruction of the user, receiving and verifying payment credentials of the user), and the like. Accordingly, the required session data includes the payment order determined through the interactive process of payment order, and the confirmed payment instruction and payment certificate acquired through the interactive process of payment verification. The business data processing may specifically include settlement processing of payment orders.

It should be noted that the above listed application scenarios, service data processing requests, data interaction processes, session data, and service data processing are only schematic illustrations. In specific implementation, the service data processing method provided by the present specification may be applied to other application scenarios, and correspondingly, the service data processing request, the data interaction process, and the session data, and the service data processing may further include other types of service data processing requests, data interaction processes, session data, and service data processing. The present specification is not limited to these.

It should be noted that the information data related to the user referred to in the present specification is information data that is acquired and used on the premise that the user knows and agrees. Moreover, the acquisition, storage, use, processing and the like of the information data all conform to relevant regulations of national laws and regulations.

In some embodiments, for a target terminal, in a specific implementation, it may be detected whether a trigger operation related to service data processing initiated by a target user is received; under the condition of detecting the trigger operation, the target terminal can detect whether the last interaction process which is latest with the service processing system is finished. And under the condition that the last interactive process is determined to be finished and no interruption exists, generating and sending a target service data processing request without carrying a session identifier. On the contrary, when it is determined that the last interaction process is not finished and there is an interruption, the target session identifier provided by the server docked in the last interaction process can be obtained through query, and further, a target service data processing request at least carrying the target session identifier can be generated and sent.

The target session identifier may be specifically understood as identifier information used to indicate that the target terminal is in an existing target session data during the last unfinished interaction process of the service processing. Specifically, the target session identifier may be a session fingerprint corresponding to target session data one to one. Of course, the target session identifier may also be identification information associated with identification information of the target terminal (e.g., a MAC address, an IP address, etc. of the target terminal).

In some embodiments, the local session data record contains one or more session data; wherein the content of the first and second substances, the session data respectively correspond to a session identifier.

Based on the above embodiment, the server can timely store the session data generated by the server during the interaction with the terminal by using the local session data record with relatively small storage burden.

In some embodiments, the session data further includes a session time.

Specifically, when the server stores the session data into the local session data record, the server may add a corresponding timestamp to the stored session data according to the session time, so as to represent the session time of the session data.

Based on the above embodiment, the server may store the session data and the session time of the session data into the local session data record together, so as to facilitate subsequent data processing.

In some embodiments, the local session data record may be a storage structure in a cache module local to the server. In order to reduce the storage burden on the server, the storage amount of the above-described local session data record may be set relatively small.

In some embodiments, when it is determined that the target session identifier does not exist in the local session data record, the performing session data synchronization with the shared cache database according to the preset synchronization rule to obtain the synchronized local session data record may include: acquiring the current stored full session data in a shared cache database according to a preset synchronization rule; and further, the synchronized local session data record can be obtained by combining the current stored full session data in the shared cache database and the existing session data in the local session data record.

In order to reduce the storage burden on the local server, the method may further include: acquiring target session data which is currently stored in a shared cache database and matched with the target session identifier according to a preset synchronization rule; and storing the target session data into the local session data record to obtain the synchronized local session data record.

In some embodiments, referring to fig. 3, when the corresponding service data processing is performed according to the synchronized local session data record, the specific implementation may include the following contents:

s1: acquiring target session data from the synchronized local session data records according to the target session identification;

s2: detecting whether target session data are complete or not according to the target service data processing request;

s3-1: under the condition that the target session data are determined to be complete, a target service data processing request can be responded directly according to the target session data, and corresponding service data processing is carried out;

s3-2: under the condition that the target session data are determined to be incomplete, the target session data can be used as an interaction starting point to carry out supplementary interaction with the target terminal so as to obtain supplementary session data in the supplementary interaction process; storing the supplementary session data in the local session data record according to the target session identifier;

s4: combining the target session data and the supplementary session data to obtain complete session data aiming at the target service data processing request;

s5: and responding to the target service data processing request according to the complete session data, and performing corresponding service data processing.

Therefore, the target service data processing request can be responded more efficiently, and corresponding service data processing is completed.

In some embodiments, in the process of processing the target service data processing request according to the synchronized local session data record, when the method is implemented, the method may further include: and storing the related session data involved in the processing process into a local session data record according to the target session identifier.

Based on the embodiment, the server can store the acquired session data into the local session data record in time in the interaction process with the target terminal so as to facilitate subsequent use.

In some embodiments, the method, when implemented, may further include:

s1: detecting whether first invalid session data with the storage time exceeding a first effective duration exists in a current local session data record or not at each preset first time interval according to the session time of the session data;

s2: and in the case that the first failure session data exists in the current local session data record, deleting the first failure session data from the current local session data record.

The preset first time interval may be specifically 4 minutes. The first effective time period may be a relatively short time period threshold, for example, 5 minutes. The above-mentioned storage time may specifically be understood as the difference between the current time and the session time.

Based on the above embodiment, the server may remove the first invalid session data that has been invalidated in the local session data record in time according to the first effective duration and the session time at every preset first time interval, so as to further reduce the local storage burden on the server.

In some embodiments, the method, when implemented, may further include: and uploading the current local session data record to the shared cache database at a preset second time interval so as to update the session data stored in the shared cache database.

Wherein, the preset second time interval may be 4 minutes.

In specific implementation, after the server uploads the current local session data record of the server to the shared cache database, the server may update the session data stored in the shared cache database according to the following manner: according to the session identification, combining session data with the same session identification in the shared cache database to obtain combined session data; and analyzing the content of the combined session data, and deleting the repeated content data in the combined session data according to the content analysis result.

Based on the above embodiment, each server in the cluster may upload the current local session data record of the server to the shared cache database at regular time, and update the session data stored in the shared cache database in time, so that the shared cache database can better store the full session data in the current time period of the service processing system.

In some embodiments, when the method is implemented while uploading the current local session data record to the shared cache database, the method may further include the following:

s1: accessing the shared cache database, and detecting whether second invalid session data with the storage time exceeding a second effective duration exists in the current shared cache database according to the session time of the session data;

s2: and under the condition that the second failure session data exist in the current shared cache database, deleting the second failure session data from the current shared cache database.

The second effective time period may be a relatively long time period threshold, for example, 15 minutes. The second effective duration is greater than or equal to the first effective duration.

Based on the above embodiment, the server may, while uploading the local session data record, timely clear the invalidated second invalidation session data in the shared cache database according to the second validity duration and the session time, so as to ensure that the shared cache database has a suitable storage space and can continue to store new session data; in addition, because the second effective duration aiming at the shared cache database is set to be larger than the first effective duration aiming at the local session data record of the server, the storage advantage of the shared cache database can be effectively utilized to store relatively more and more full session data, so as to further reduce the local storage burden of the server.

In some embodiments, the server may be further configured to automatically detect whether the local session data record is updated, and upload the local session data record to the shared cache database in case that the local session data record is updated. The server may be further configured to automatically detect whether there is first stale session data to be deleted in the local session data record; and under the condition that the first failure session data exists, uploading the local session data record before the first failure session data is deleted to the shared cache database.

In some embodiments, the session data may specifically further carry a status tag for indicating whether the interaction process is ended. The state tag can be understood as a state tag of an interactive process related to the target session data.

Based on the above embodiment, a state tag of the interaction process corresponding to the session data may be further added to the stored session data to represent an actual state of the interaction process, so that the related data processing may be completed more accurately in the following.

In some embodiments, the method, when implemented, may further include: and uploading the session data with the status label of unfinished in the current local session data record to the shared cache database at a preset second time interval so as to update the session data stored in the shared cache database.

Based on the above embodiment, the server can distinguish session data in the interaction process of different states according to the state tags in the session data each time the session data is uploaded, and only the session data with the state tags of unfinished state is uploaded to the shared cache database, so that the data storage burden of the shared cache database can be effectively reduced.

Further, the server may detect the state tag of the session data stored in the current local session data record at every preset first time interval, and delete the session data whose state tag is already ended in time.

In some embodiments, referring to fig. 4, after detecting whether the target service data processing request carries the target session identifier, when the method is implemented specifically, the following may be further included:

s1: generating a target session identifier under the condition that the target service data processing request is determined not to carry the target session identifier; and providing the target session identification for a target terminal;

s2: interacting with a target terminal to acquire related session data; storing the session data in the local session data record according to the target session identifier;

s3: and according to the session data, carrying out corresponding service data processing.

In specific implementation, the server may generate, by using a preset random number generator, a random number corresponding to the target service data processing request as the target session identifier according to the receiving time or the request number of the target service data processing request and/or the identifier information of the target terminal.

In specific implementation, the server can generate and send a session request to the target terminal before generating the target session identifier and starting to interact with the target terminal; the session request may carry a target session identifier. Accordingly, the target terminal may obtain the target session identifier. In particular, the target terminal may store the target session identification in locally cookie data.

In specific implementation, in the process of interaction between the server and the target terminal, a recording area with the target session identifier as a recording identifier may be added to the local session data record according to the target session identifier; and recording the session data acquired or updated in real time in the recording area.

Based on the embodiment, the server can automatically generate the corresponding target session identifier in the process of interacting with the target terminal; and recording the session data generated in real time in the interaction process in the local session data record in time according to the target session identification.

In some embodiments, after querying the local session data record according to the target session identifier, when the method is implemented, the following may be further included: and under the condition that the target session identification exists in the local session data record, performing corresponding service data processing according to the local session data record.

Based on the above embodiment, when the target session identifier exists in the local session data record, the target session data in the local session data record can be directly obtained and utilized, and the corresponding service data processing can be efficiently completed.

In some embodiments, the performing, according to the local session data record, corresponding service data processing may include: acquiring target session data according to the local session data record; detecting whether target session data are complete or not according to the target service data processing request; and under the condition of determining that the target session data is complete, responding to the target service data processing request according to the target session data, and performing corresponding service data processing. Under the condition that the target session data are determined to be incomplete, the target session data are used as an interaction starting point to carry out supplementary interaction with the target terminal so as to obtain supplementary session data; storing the supplementary session data in the local session data record according to the target session identifier; combining the target session data and the supplementary session data to obtain complete session data aiming at the target service data processing request; and responding to the target service data processing request according to the complete session data, and performing corresponding service data processing.

In some embodiments, the shared cache database may specifically include a block chain-based distributed database. Therefore, the shared cache database can be used for storing the session data in the interaction process more safely and trustiny, the relevant session data is prevented from being tampered, and the safety and the reliability of the stored session data are effectively guaranteed.

In some embodiments, after performing corresponding service data processing according to the local session data record, the method further includes: obtaining a target service data processing result; and sending the target service data processing result to the target terminal.

As can be seen from the above, in the service data processing method provided in this specification, after receiving a target service data processing request initiated by a target user through a target terminal, a service processing system may distribute the target service data processing request to a server in a server cluster, where the server currently meets requirements for processing. After receiving a target service data processing request, a server detects whether the target service data processing request carries a target session identifier; the target session identifier is used for indicating target session data in the last unfinished interactive process of the target terminal and the service processing system; under the condition that the target service data processing request is determined to carry the target session identifier, inquiring a local session data record according to the target session identifier; under the condition that the target session identification does not exist in the local session data record, carrying out session data synchronization with a shared cache database according to a preset synchronization rule to obtain a synchronized local session data record; and performing corresponding service data processing according to the synchronized local session data record. Therefore, a server which is newly butted with the target terminal in the service processing system can completely acquire and utilize target session data which is existed in the last unfinished interactive process of the target terminal and the service processing system, and corresponding service data processing is continuously carried out based on the last unfinished interactive process, so that a target user does not need to repeat the interactive flow which is already carried out in the last interactive process, the overall processing efficiency is improved, the waiting time of the target user is shortened, and the target user can obtain relatively good interactive experience; meanwhile, as the shared cache database is additionally introduced and used in the service processing system to cache the session data of each server, the local storage burden of the servers is effectively reduced.

Referring to fig. 5, an embodiment of the present specification further provides a service data processing method. The method is applied to one side of a target terminal, and when the method is implemented specifically, the method can comprise the following steps:

s501: under the condition that the trigger operation initiated by the target user is detected, detecting whether the last interactive process with the service processing system is finished or not;

s502: under the condition that the last interactive process with the service processing system is not finished, acquiring a target session identifier indicating target session data in the last interactive process;

s503: responding to the trigger operation, and generating a target service data processing request carrying a target session identifier;

s504: and sending the target service data processing request to a service processing system.

The triggering operation may be specifically understood as an operation initiated by a target user on a target terminal to instruct to perform target service data processing. For example, the target user clicks on the relevant service item icon presented on the target terminal.

In specific implementation, when it is determined that the last interaction process with the service processing system has ended, the target terminal may generate a target service data processing request without a session identifier, and send the target service data processing request to the service processing system.

Based on the embodiment, the target terminal can be well matched with the server of the service processing system, so that the server newly butted with the target terminal in the service processing system can completely acquire and utilize the target session data existing in the last unfinished interactive process of the target terminal and the service processing system, and the corresponding service data processing is continuously carried out based on the last unfinished interactive process, so that the target user does not need to repeat the interactive flow already carried out in the last interactive process, the overall processing efficiency is improved, the waiting time of the target user is shortened, and the target user can obtain relatively better interactive experience; meanwhile, because a shared cache database is additionally introduced and used in the service processing system to cache the session data of each server, the local storage burden of the servers is effectively reduced.

Embodiments of the present specification further provide a server, including a processor and a memory for storing processor-executable instructions, where the processor, when implemented, may perform the following steps according to the instructions: receiving a target service data processing request initiated by a target terminal; detecting whether a target service data processing request carries a target session identifier or not; the target session identifier is used for indicating target session data in the last unfinished interactive process of the target terminal and the service processing system; under the condition that the target service data processing request is determined to carry the target session identifier, inquiring a local session data record according to the target session identifier; under the condition that the target session identification does not exist in the local session data record, session data synchronization is carried out through the shared cache database according to a preset synchronization rule, and the synchronized local session data record is obtained; and performing corresponding service data processing according to the synchronized local session data record.

In order to more accurately complete the above instructions, referring to fig. 6, another specific server is provided in the embodiments of the present specification, where the server includes a network communication port 601, a processor 602, and a memory 603, and the above structures are connected by an internal cable, so that the structures may perform specific data interaction.

The network communication port 601 may be specifically configured to receive a target service data processing request initiated by a target terminal.

The processor 602 may be specifically configured to detect whether the target service data processing request carries a target session identifier; the target session identifier is used for indicating target session data in the last unfinished interactive process of the target terminal and the service processing system; under the condition that the target service data processing request is determined to carry the target session identifier, inquiring a local session data record according to the target session identifier; under the condition that the target session identification does not exist in the local session data record, session data synchronization is carried out through the shared cache database according to a preset synchronization rule, and the synchronized local session data record is obtained; and performing corresponding service data processing according to the synchronized local session data record.

The memory 603 may be specifically configured to store a corresponding instruction program.

In this embodiment, the network communication port 601 may be a virtual port bound with different communication protocols, so that different data can be sent or received. For example, the network communication port may be a port responsible for web data communication, a port responsible for FTP data communication, or a port responsible for mail data communication. In addition, the network communication port can also be a communication interface or a communication chip of an entity. For example, it may be a wireless mobile network communication chip, such as GSM, CDMA, etc.; it can also be a Wifi chip; it may also be a bluetooth chip.

In this embodiment, the processor 602 may be implemented in any suitable manner. For example, the processor may take the form of, for example, a microprocessor or processor and a computer-readable medium that stores computer-readable program code (e.g., software or firmware) executable by the (micro) processor, logic gates, switches, an Application Specific Integrated Circuit (ASIC), a programmable logic controller, an embedded microcontroller, and so forth. The description is not intended to be limiting.

In this embodiment, the memory 603 may include multiple layers, and in a digital system, the memory may be any memory as long as it can store binary data; in an integrated circuit, a circuit without a real form and with a storage function is also called a memory, such as a RAM, a FIFO and the like; in the system, the storage device in physical form is also called a memory, such as a memory bank, a TF card and the like.

An embodiment of the present specification further provides a target terminal, including a processor and a memory for storing processor-executable instructions, where the processor, when implemented specifically, may perform the following steps according to the instructions: under the condition that the trigger operation initiated by the target user is detected, detecting whether the last interactive process with the service processing system is finished or not; under the condition that the last interactive process with the service processing system is not finished, acquiring a target session identifier indicating target session data in the last interactive process; responding to the trigger operation, and generating a target service data processing request carrying a target session identifier; and sending the target service data processing request to a service processing system.

An embodiment of the present specification further provides a computer-readable storage medium based on the foregoing service data processing method, where the computer-readable storage medium stores computer program instructions, and when the computer program instructions are executed, the computer-readable storage medium implements: receiving a target service data processing request initiated by a target terminal; detecting whether a target service data processing request carries a target session identifier or not; the target session identifier is used for indicating target session data in the last unfinished interactive process of the target terminal and the service processing system; under the condition that the target service data processing request is determined to carry the target session identifier, inquiring a local session data record according to the target session identifier; under the condition that the target session identification does not exist in the local session data record, session data synchronization is carried out through the shared cache database according to a preset synchronization rule, and the synchronized local session data record is obtained; and performing corresponding service data processing according to the synchronized local session data record.

An embodiment of the present specification further provides another computer-readable storage medium based on the foregoing service data processing method, where the computer-readable storage medium stores computer program instructions, and when the computer program instructions are executed, the computer-readable storage medium implements: under the condition that the trigger operation initiated by the target user is detected, detecting whether the last interactive process with the service processing system is finished or not; under the condition that the last interactive process with the service processing system is not finished, acquiring a target session identifier indicating target session data in the last interactive process; responding to the trigger operation, and generating a target service data processing request carrying a target session identifier; and sending the target service data processing request to a service processing system.

In this embodiment, the storage medium includes, but is not limited to, a Random Access Memory (RAM), a Read-Only Memory (ROM), a Cache (Cache), a Hard Disk Drive (HDD), or a Memory Card (Memory Card). The memory may be used to store computer program instructions. The network communication unit may be an interface for performing network connection communication, which is set in accordance with a standard prescribed by a communication protocol.

In this embodiment, the functions and effects specifically realized by the program instructions stored in the computer-readable storage medium can be explained in comparison with other embodiments, and are not described herein again.

Referring to fig. 7, in a software layer, an embodiment of the present specification further provides a service data processing apparatus, which may specifically include the following structural modules:

the receiving module 701 may be specifically configured to receive a target service data processing request initiated by a target terminal;

the detecting module 702 may be specifically configured to detect whether the target service data processing request carries a target session identifier; the target session identifier is used for indicating target session data in the last unfinished interactive process of the target terminal and the service processing system;

the query module 703 may be specifically configured to query the local session data record according to the target session identifier when it is determined that the target service data processing request carries the target session identifier;

the synchronization module 704 may be specifically configured to, when it is determined that the target session identifier does not exist in the local session data record, perform session data synchronization with the shared cache database according to a preset synchronization rule to obtain a synchronized local session data record;

the processing module 705 may be specifically configured to perform corresponding service data processing according to the synchronized local session data record.

In some embodiments, the local session data record may specifically contain one or more session data; wherein the session data respectively correspond to a session identifier.

In some embodiments, the session data may specifically include a session time.

In some embodiments, the processing module 705, in the process of processing the target service data processing request according to the synchronized local session data record, when implemented specifically, may be further configured to store, according to the target session identifier, the related session data involved in the processing process into the local session data record.

In some embodiments, when the device is implemented, the device may further be configured to detect, at every preset first time interval, according to session time of session data, whether first failure session data whose storage time exceeds a first effective duration exists in a current local session data record; and in the case that the first failure session data exists in the current local session data record, deleting the first failure session data from the current local session data record.

In some embodiments, when the apparatus is implemented, the apparatus may be further configured to upload the current local session data record to the shared cache database at a preset second time interval, so as to update the session data stored in the shared cache database.

In some embodiments, the apparatus may be further configured to access the shared cache database while uploading the current local session data record to the shared cache database, and detect whether there is second failure session data whose storage time exceeds a second validity time in the current shared cache database according to the session time of the session data; and under the condition that the second failure session data exist in the current shared cache database, deleting the second failure session data from the current shared cache database.

In some embodiments, the session data may further specifically carry a status tag for indicating whether the interaction process is finished.

In some embodiments, when the apparatus is implemented, the apparatus may further be configured to upload, to the shared cache database, session data whose state tag is not ended in the current local session data record at every preset second time interval, so as to update the session data stored in the shared cache database.

In some embodiments, after detecting whether the target service data processing request carries the target session identifier, the apparatus may be further configured to generate the target session identifier when it is determined that the target service data processing request does not carry the target session identifier in specific implementation; and providing the target session identification for a target terminal; interacting with a target terminal to acquire related session data; storing the session data in the local session data record according to the target session identifier; and according to the session data, performing corresponding service data processing.

In some embodiments, after querying the local session data record according to the target session identifier, the device may be further configured to perform corresponding service data processing according to the local session data record when it is determined that the target session identifier exists in the local session data record.

Referring to fig. 8, in a software layer, an embodiment of the present specification further provides another service data processing apparatus, which may specifically include the following structural modules:

the detecting module 801 may be specifically configured to detect whether a last interaction process with the service processing system is ended when a trigger operation initiated by a target user is detected;

the obtaining module 802 may be specifically configured to, in a case that it is determined that a last interaction process with the service processing system is not completed, obtain a target session identifier indicating target session data in the last interaction process;

the generating module 803 may specifically be configured to generate a target service data processing request carrying a target session identifier in response to the trigger operation;

the sending module 804 may be specifically configured to send the target service data processing request to a service processing system.

It should be noted that, the units, devices, modules, and the like described in the foregoing embodiments may be specifically implemented by a computer chip or an entity, or implemented by a product with certain functions. For convenience of description, the above devices are described as being divided into various modules by functions, and are described separately. It is to be understood that, in implementing the present specification, functions of each module may be implemented in one or more pieces of software and/or hardware, or a module that implements the same function may be implemented by a combination of a plurality of sub-modules or sub-units, or the like. The above-described embodiments of the apparatus are merely illustrative, and for example, the division of the units is only one logical division, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.

As can be seen from the above, based on the service data processing apparatus provided in this specification, a server in a service processing system, which is newly docked with a target terminal, can completely acquire and utilize target session data existing in a last unfinished interaction process between the target terminal and the service processing system, and based on the last unfinished interaction process, continue to perform corresponding service data processing without repeating an interaction flow already performed in the last interaction process by the target user, so that the overall processing efficiency is improved, the waiting time of the target user is shortened, and the target user can obtain relatively better interaction experience; meanwhile, as the shared cache database is additionally introduced and used in the service processing system to cache the session data of each server, the local storage burden of the servers is effectively reduced.

Although the present specification provides method steps as described in the examples or flowcharts, additional or fewer steps may be included based on conventional or non-inventive means. The order of steps recited in the embodiments is merely one manner of performing the steps in a multitude of sequences, and does not represent a unique order of performance. When an apparatus or client product in practice executes, it may execute sequentially or in parallel (e.g., in a parallel processor or multithreaded processing environment, or even in a distributed data processing environment) according to the embodiments or methods shown in the figures. The terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, the presence of additional identical or equivalent elements in a process, method, article, or apparatus that comprises the recited elements is not excluded. The terms first, second, etc. are used to denote names, but not to denote any particular order.

Those skilled in the art will also appreciate that, in addition to implementing the controller as pure computer readable program code, the same functionality can be implemented by logically programming method steps such that the controller is in the form of logic gates, switches, application specific integrated circuits, programmable logic controllers, embedded microcontrollers and the like. Such a controller may therefore be considered as a hardware component, and the means included therein for performing the various functions may also be considered as a structure within the hardware component. Or even means for performing the functions may be regarded as being both a software module for performing the method and a structure within a hardware component.

This description may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, classes, etc. that perform particular tasks or implement particular abstract data types. The specification may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer-readable storage media including memory storage devices.

From the above description of the embodiments, it is clear to those skilled in the art that the present specification can be implemented by software plus necessary general hardware platform. With this understanding, the technical solutions in the present specification may be essentially embodied in the form of a software product, which may be stored in a storage medium, such as a ROM/RAM, a magnetic disk, an optical disk, etc., and includes several instructions for enabling a computer device (which may be a personal computer, a mobile terminal, a server, or a network device, etc.) to execute the methods described in the embodiments or some parts of the embodiments in the present specification.

The embodiments in the present specification are described in a progressive manner, and the same or similar parts among the embodiments are referred to each other, and each embodiment focuses on the differences from the other embodiments. The description is operational with numerous general purpose or special purpose computing system environments or configurations. For example: personal computers, server computers, hand-held or portable devices, tablet-type devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable electronic devices, network PCs, minicomputers, mainframe computers, distributed computing environments that include any of the above systems or devices, and the like.

While the specification has been described with examples, those skilled in the art will appreciate that there are numerous variations and permutations of the specification that do not depart from the spirit of the specification, and it is intended that the appended claims include such variations and modifications that do not depart from the spirit of the specification.

Claims

1. A service data processing method is applied to a server in a service processing system, wherein the service processing system comprises a server cluster and a shared cache database, and the method comprises the following steps:

detecting whether the target service data processing request carries a target session identifier or not; the target session identifier is used for indicating target session data in the last unfinished interaction process of the target terminal and the service processing system;

2. The method of claim 1, wherein the local session data record contains one or more session data; wherein the session data respectively corresponds to a session identifier.

3. The method of claim 2, wherein the session data further comprises a session time.

4. The method of claim 3, wherein in processing the target service data processing request according to the synchronized local session data record, the method further comprises: and storing the related session data involved in the processing process into a local session data record according to the target session identifier.

5. The method of claim 3, further comprising:

detecting whether first failure session data with the storage time exceeding a first effective duration exists in a current local session data record or not at each preset first time interval according to the session time of the session data;

and under the condition that the first failure session data exist in the current local session data record, deleting the first failure session data from the current local session data record.

6. The method of claim 3, further comprising:

7. The method of claim 6, wherein while uploading the current local session data record to the shared cache database, the method further comprises:

8. The method of claim 6, wherein the session data further carries a status tag indicating whether the interactive process is finished.

9. The method of claim 8, further comprising:

10. The method of claim 1, wherein after detecting whether the target service data processing request carries the target session identifier, the method further comprises:

generating a target session identifier under the condition that the target service data processing request is determined not to carry the target session identifier; and providing the target session identification for a target terminal;

and according to the session data, performing corresponding service data processing.

11. The method of claim 1, wherein after querying the local session data record based on the target session identification, the method further comprises:

and under the condition that the target session identifier exists in the local session data record, carrying out corresponding service data processing according to the local session data record.

12. A service data processing method is applied to a target terminal and comprises the following steps:

13. A service data processing apparatus, applied to a server in a service processing system, where the service processing system includes a server cluster and a shared cache database, the apparatus comprising:

14. A server comprising a processor and a memory for storing processor-executable instructions which, when executed by the processor, implement the steps of the method of any one of claims 1 to 11.

15. A computer-readable storage medium having stored thereon computer instructions which, when executed by a processor, carry out the steps of the method of any one of claims 1 to 11, or 12.