CN115920371A - Game service request processing method, device, computer equipment and storage medium - Google Patents

Abstract

The disclosure relates to a game service request processing method and device, computer equipment and a storage medium, and belongs to the technical field of computers. The method comprises the following steps: responding to a game service request of an account, and determining the service type of the game service request; determining a service interface matched with the non-real-time service under the condition that the service type indicates that the game service is the non-real-time service; inquiring the address of a service server for providing the service interface from the service registry; based on the service interface, a RPC request is sent to the address. According to the method and the system, the user load related to the non-real-time service is migrated to the service server, the iteration and the update of the non-real-time service only need to modify the code logic in the service server, and the patching of the main service logic of the game is not involved, so that the game development efficiency is improved, and when some service functions are blocked, the normal use of other service functions or the main service logic is not influenced, so that the game availability is improved.

Description

Game service request processing method, device, computer equipment and storage medium

technical field

The present disclosure relates to the field of computer technology, and in particular to a method, device, computer equipment and storage medium for processing game service requests.

Background technique

With the development of computer technology and the popularization of mobile terminals, mobile games have gradually become a relatively popular game type. In the current game back-end development technology, an integral structure is adopted to design the main logic of the game’s business. For example, services such as ray detection, damage calculation, game chat, and game email collection are all supported by the main logic process at the back-end of the game server. .

However, in an online game scenario that involves frequent communication between multiple users, the amount of code will continue to accumulate with business iterations and version updates. When modifying or adding new services in the overall architecture, the development complexity will become higher and higher. , and when a certain business function is blocked, the entire main logic process may be unavailable. Therefore, the game development efficiency and game availability of the overall architecture are low.

Contents of the invention

The present disclosure provides a game service request processing method, device, computer equipment, and storage medium, so as to at least improve game development efficiency and game usability. The disclosed technical scheme is as follows:

According to an aspect of an embodiment of the present disclosure, a method for processing a game service request is provided, including:

Responding to the game service request of the account, determining the service type of the game service request, the service type indicating the timeliness attribute of the game service associated with the game service request;

When the service type indicates that the game service is a non-real-time service, determine a service interface that matches the non-real-time service;

Query the address of the service server for providing the service interface from the service registration center, and the service registration center is used to record the addresses of the service servers of various interfaces;

Sending a remote procedure call (RPC) request to the address based on the service interface, where the RPC request is used to instruct the service server to provide the account with a response to the game service.

In some embodiments, the querying the address of the service server for providing the service interface from the service registry includes:

From the service registration center, query the set of addresses used to provide the service interface;

From the address set, query the address of the service server with the closest geographic distance to the account.

In some embodiments, the method also includes:

Create a coroutine of the non-real-time service through the service server in response to the RPC request;

Initiating the database operation of the non-real-time service through the coroutine;

Before obtaining the operation result of the operation on the database, block and suspend the coroutine;

After the operation result of the database operation is acquired, a response generated based on the operation result is returned.

In some embodiments, the game service request is a mailing list pull request; the database operation of initiating the non-real-time service through the coroutine includes:

Obtain the maximum personal email serial number and the largest system email serial number in the pulled emails of the account from the mailing list pull request through the coroutine;

Based on the maximum personal mail serial number, initiate a batch read operation of personal mail to the personal mail collection of the account in the database, and the batch read operation is used to read mail whose serial number is greater than the maximum personal mail serial number multiple personal emails from

Based on the maximum system mail serial number, a batch read operation of system mail is initiated to the system mail collection of the database, and the batch read operation is used to read multiple system mails whose serial number is greater than the maximum system mail serial number mail.

In some embodiments, the game service request is a mailing list pull request; the database operation of initiating the non-real-time service through the coroutine includes:

Obtaining the maximum mail sequence number among the pulled mails of the account carried in the mailing list pull request through the coroutine;

Based on the maximum mail sequence number, initiate a batch read operation of system mail to the system mail collection of the database, the batch read operation is used to read multiple system mails whose mail sequence numbers are greater than the maximum mail sequence number;

storing the plurality of system emails into the personal email collection of the account in the database;

Based on the maximum mail sequence number, a batch read operation of mails is initiated to the personal mail collection, and the batch read operation is used to read a plurality of mails whose mail sequence numbers are greater than the maximum mail sequence number.

In some embodiments, the method also includes:

Determine the number of unread emails based on the plurality of emails returned by the operation result of the batch read operation;

extracting information summaries of the plurality of emails, where the information summaries are used to provide at least one of the following: email type, email title, sender information, email timestamp and whether it contains attachments;

A response carrying the message digest and the number of unread emails is generated.

In some embodiments, the method also includes:

In the case where the number of multiple mailing list pull requests received in the same time period exceeds the request volume threshold, multiple RPC requests associated with the multiple mailing list pull requests are cached by the business server and sent to the message queue middle;

In the message queue, merge the RPC requests associated with the same mailing list pull request sent by the same initiating account multiple times, and configure the request times variable for the initiating account;

Reordering each RPC request in the message queue based on the request times variable;

At least one RPC request in the current batch in the reordered message queue is processed in batches at each target time interval.

In some embodiments, the game service request is a pull request for email details; the database operation of initiating the non-real-time service through the coroutine includes:

Determine the email type and email serial number requested by the email details pull request through the coroutine;

To the mail set indicated by the mail type in the database, initiate a read operation on the mail indicated by the mail sequence number, the read operation is used to read the mail body of the mail, and The attachment is also read if it is carried.

In some embodiments, the game service request is an email sending request; the database operation of initiating the non-real-time service through the coroutine includes:

determining the mail type of the mail to be sent indicated by the mail sending request through the coroutine;

In the case that the email type is personal email, initiate a write operation of the email to be sent to the personal email collection of the account in the database;

In the case that the email type is a system email, a write operation of the email to be sent is initiated to the system email collection of the database.

In some embodiments, the method also includes:

assigning a mail serial number to the mail to be sent based on the operation result of the writing operation;

When the recipient account of the email to be sent is offline in the game, generate a response to notify the account that the email is sent successfully;

When the recipient account of the email to be sent is online in the game, generate a response to notify the account that the email is successfully sent; and generate a response to push the email to the recipient account.

In some embodiments, the game service request is an unread message pull request; the database operation of initiating the non-real-time service through the coroutine includes:

Obtain an account to be queried and a maximum message identifier from the unread message pull request through the coroutine, where the maximum message identifier indicates the latest read message in a conversation between the account and the account to be queried;

Based on the maximum message identifier, initiate a batch read operation of unread messages to the message set of the account and the account to be queried in the database, and the batch read operation is used to read a message whose identifier is greater than the maximum message Multiple messages identified.

In some embodiments, the method also includes:

determining the number of unread messages based on the multiple messages returned by the operation result of the batch read operation;

A response carrying the plurality of unread messages and the number of unread messages is generated.

In some embodiments, the game service request is a message sending request; the database operation of initiating the non-real-time service through the coroutine includes:

determining the message type of the message to be sent indicated by the message sending request through the coroutine;

In the case that the message type is a personal message, initiate a write operation on the message to be sent to the message set of the account and message receiving account in the database;

In the case that the message type is a group message, a write operation of the message to be sent is initiated to the message set of the message receiving group in the database.

In some embodiments, the method also includes:

Based on the operation result of the write operation, assign a message identifier to the message to be sent, and generate a response to notify the account that the message is successfully sent;

For the personal message, generate a response to push the message to be sent to the message receiving account only when the message receiving account is in the online state of the game;

For the group message, pull the latest member list of the message receiving group; only for the online member accounts in the latest member list, generate a response to push the message to be sent to the online member account.

In some embodiments, the game service request is an account addition request, and the account addition request is used to apply for adding the target account to the account relationship chain of the account; Business database operations include:

Perform authority verification on the account through the coroutine;

After the verification is passed, initiate a database operation of writing the account addition record of the account to the target account to the database;

After obtaining the operation result of the database operation, returning a response generated based on the operation result includes:

When the operation result indicates that writing of the account addition record is completed, an account addition notification response to the target account is generated.

According to another aspect of the embodiments of the present disclosure, an apparatus for processing game service requests is provided, including:

The determining unit is configured to execute a game service request in response to an account, determine a service type of the game service request, and the service type indicates the timeliness attribute of the game service associated with the game service request;

The determining unit is further configured to determine a service interface matching the non-real-time service when the service type indicates that the game service is a non-real-time service;

The query unit is configured to query the address of the service server for providing the service interface from the service registration center, and the service registration center is used to record the addresses of the service servers of various interfaces;

The sending unit is configured to send a remote procedure call (RPC) request to the address based on the service interface, and the RPC request is used to instruct the service server to provide the account with a response to the game service.

In some embodiments, the query unit is configured to perform:

From the service registration center, query the set of addresses used to provide the service interface;

From the address set, query the address of the service server with the closest geographic distance to the account.

In some embodiments, the device also includes:

a creation unit configured to execute a coroutine for creating the non-real-time service in response to the RPC request through the service server;

an initiating unit configured to execute the database operation of initiating the non-real-time service through the coroutine;

A blocking unit configured to block and suspend the coroutine before obtaining the operation result of the database operation;

The returning unit is configured to, after obtaining the operation result of the database operation, return a response generated based on the operation result.

In some embodiments, the game service request is a mailing list pull request; the initiating unit is configured to perform:

Obtain the maximum personal email serial number and the largest system email serial number in the pulled emails of the account from the mailing list pull request through the coroutine;

Based on the maximum personal mail serial number, initiate a batch read operation of personal mail to the personal mail collection of the account in the database, and the batch read operation is used to read mail whose serial number is greater than the maximum personal mail serial number multiple personal emails from

Based on the maximum system mail serial number, a batch read operation of system mail is initiated to the system mail collection of the database, and the batch read operation is used to read multiple system mails whose serial number is greater than the maximum system mail serial number mail.

In some embodiments, the game service request is a mailing list pull request; the initiating unit is configured to perform:

Obtaining the maximum mail sequence number among the pulled mails of the account carried in the mailing list pull request through the coroutine;

Based on the maximum mail sequence number, initiate a batch read operation of system mail to the system mail collection of the database, the batch read operation is used to read multiple system mails whose mail sequence numbers are greater than the maximum mail sequence number;

storing the plurality of system emails into the personal email collection of the account in the database;

Based on the maximum mail sequence number, a batch read operation of mails is initiated to the personal mail collection, and the batch read operation is used to read a plurality of mails whose mail sequence numbers are greater than the maximum mail sequence number.

In some embodiments, the apparatus further includes a generating unit configured to:

Determine the number of unread emails based on the plurality of emails returned by the operation result of the batch read operation;

extracting information summaries of the plurality of emails, where the information summaries are used to provide at least one of the following: email type, email title, sender information, email timestamp and whether it contains attachments;

A response carrying the message digest and the number of unread emails is generated.

In some embodiments, the apparatus further comprises a batch processing unit configured to perform:

In the case where the number of multiple mailing list pull requests received in the same time period exceeds the request volume threshold, multiple RPC requests associated with the multiple mailing list pull requests are cached by the business server and sent to the message queue middle;

In the message queue, merge the RPC requests associated with the same mailing list pull request sent by the same initiating account multiple times, and configure the request times variable for the initiating account;

Reordering each RPC request in the message queue based on the request times variable;

At least one RPC request in the current batch in the reordered message queue is processed in batches at each target time interval.

In some embodiments, the game service request is a pull request for email details; the initiating unit is configured to perform:

Determine the email type and email serial number requested by the email details pull request through the coroutine;

To the mail set indicated by the mail type in the database, initiate a read operation on the mail indicated by the mail sequence number, the read operation is used to read the mail body of the mail, and The attachment is also read if it is carried.

In some embodiments, the game service request is an email sending request; the initiating unit is configured to perform:

determining the mail type of the mail to be sent indicated by the mail sending request through the coroutine;

In the case that the email type is personal email, initiate a write operation of the email to be sent to the personal email collection of the account in the database;

In the case that the email type is a system email, a write operation of the email to be sent is initiated to the system email collection of the database.

In some embodiments, the apparatus further includes a generating unit configured to:

assigning a mail serial number to the mail to be sent based on the operation result of the writing operation;

When the recipient account of the email to be sent is offline in the game, generate a response to notify the account that the email is sent successfully;

When the recipient account of the email to be sent is online in the game, generate a response to notify the account that the email is successfully sent; and generate a response to push the email to the recipient account.

In some embodiments, the game service request is an unread message pull request; the initiating unit is configured to perform:

Obtain an account to be queried and a maximum message identifier from the unread message pull request through the coroutine, where the maximum message identifier indicates the latest read message in a conversation between the account and the account to be queried;

Based on the maximum message identifier, initiate a batch read operation of unread messages to the message set of the account and the account to be queried in the database, and the batch read operation is used to read a message whose identifier is greater than the maximum message Multiple messages identified.

In some embodiments, the apparatus further includes a generating unit configured to:

Determine the number of unread messages based on the multiple messages returned by the operation result of the batch read operation;

A response carrying the plurality of unread messages and the number of unread messages is generated.

In some embodiments, the game service request is a message sending request; the initiating unit is configured to perform:

determining the message type of the message to be sent indicated by the message sending request through the coroutine;

In the case that the message type is a personal message, initiate a write operation of the message to be sent to the message set of the account and message receiving account in the database;

In the case that the message type is a group message, a write operation of the message to be sent is initiated to the message set of the message receiving group in the database.

In some embodiments, the apparatus further includes a generating unit configured to:

Based on the operation result of the write operation, assign a message identifier to the message to be sent, and generate a response to notify the account that the message is successfully sent;

For the personal message, generate a response to push the message to be sent to the message receiving account only when the message receiving account is in the online state of the game;

For the group message, pull the latest member list of the message receiving group; only for the online member accounts in the latest member list, generate a response to push the message to be sent to the online member account.

In some embodiments, the game service request is an account addition request, and the account addition request is used to apply for adding the target account to the account relationship chain of the account; the initiating unit is configured to execute:

Perform authority verification on the account through the coroutine;

After the verification is passed, initiate a database operation of writing the account addition record of the account to the target account to the database;

The apparatus also includes a generating unit configured to perform:

When the operation result indicates that writing of the account addition record is completed, an account addition notification response to the target account is generated.

According to another aspect of an embodiment of the present disclosure, there is provided a computer device, including:

one or more processors;

one or more memories for storing said one or more processor-executable instructions;

Wherein, the one or more processors are configured to execute the method for processing game service requests in any possible implementation manner of the above aspect.

According to another aspect of the embodiments of the present disclosure, there is provided a computer-readable storage medium. When at least one instruction in the computer-readable storage medium is executed by one or more processors of a computer device, the computer device The method for processing game service requests in any possible implementation manner of the above aspect can be implemented.

According to another aspect of an embodiment of the present disclosure, there is provided a computer program product including one or more instructions executable by one or more processors of a computer device, so that the computer device can Execute the method for processing game service requests in any possible implementation manner of the above aspect.

The technical solutions provided by the embodiments of the present disclosure bring at least the following beneficial effects:

For game service requests that request non-real-time services, since the real-time requirements are not high, there is no need for real-time processing on the game server locally, so the service API dedicated to processing the non-real-time services can be found in the service registration center, and then through the service The API makes RPC remote calls to the remote business server, which can migrate the user load related to non-real-time business from the game server to the business server, optimize the resource configuration of the game server, and because the iteration and update for non-real-time business only It is necessary to modify the code logic in the business server, and modify the service API if necessary, which does not involve patching the main business logic of the game, reduces development complexity, improves game development efficiency, and different types of non-real-time business can be deployed separately on In different business servers, when some business functions are blocked, it will not affect the normal use of other business functions, and will not affect the main business logic of the game, which greatly improves the usability of the game.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the present disclosure.

Description of drawings

The accompanying drawings here are incorporated into the specification and constitute a part of the specification, show embodiments consistent with the disclosure, and are used together with the description to explain the principle of the disclosure, and do not constitute an improper limitation of the disclosure.

FIG. 1 is a schematic diagram of an implementation environment of a method for processing a game service request according to an embodiment of the present disclosure;

Fig. 2 is a flowchart of a method for processing a game service request according to an embodiment of the present disclosure;

Fig. 3 is an interactive flowchart of a method for processing a game service request according to an embodiment of the present disclosure;

Fig. 4 is a processing flowchart of a mailing list pulling service provided by an embodiment of the present disclosure;

FIG. 5 is a logical structure diagram of a mail database in a service server provided by an embodiment of the present disclosure;

FIG. 6 is a flow chart of a method for processing mailing list pull requests in frames according to an embodiment of the present disclosure;

Fig. 7 is a processing flow chart of an email details pulling service provided by an embodiment of the present disclosure;

Fig. 8 is a processing flowchart of an email sending service provided by an embodiment of the present disclosure;

FIG. 9 is a processing flow of an email sending service provided by an embodiment of the present disclosure;

Fig. 10 is a processing flowchart of an unread message pulling service provided by an embodiment of the present disclosure;

Fig. 11 is an interactive flowchart of an unread message pulling service provided by an embodiment of the present disclosure;

Fig. 12 is an interactive flowchart of a red dot data pulling service provided by an embodiment of the present disclosure;

Fig. 13 is a processing flowchart of a message sending service provided by an embodiment of the present disclosure;

Fig. 14 is an interaction flowchart of a message sending service provided by an embodiment of the present disclosure;

Fig. 15 is an interaction flowchart of a message sending service provided by an embodiment of the present disclosure;

Fig. 16 is a flow chart of processing an account addition service provided by an embodiment of the present disclosure;

Fig. 17 is an interaction flowchart of an account adding service provided by an embodiment of the present disclosure;

Fig. 18 is a business flow chart of a group service system provided by an embodiment of the present disclosure;

Fig. 19 is a logical structural block diagram of an apparatus for processing game service requests according to an embodiment of the present disclosure;

Fig. 20 is a schematic structural diagram of a computer device provided by an embodiment of the present disclosure.

Detailed ways

In order to enable ordinary persons in the art to better understand the technical solutions of the present disclosure, the technical solutions in the embodiments of the present disclosure will be clearly and completely described below in conjunction with the accompanying drawings.

It should be noted that the terms "first" and "second" in the specification and claims of the present disclosure and the above drawings are used to distinguish similar objects, but not necessarily used to describe a specific sequence or sequence. It is to be understood that the data so used are interchangeable under appropriate circumstances such that the embodiments of the disclosure described herein can be practiced in sequences other than those illustrated or described herein. The implementations described in the following exemplary examples do not represent all implementations consistent with the present disclosure. Rather, they are merely examples of apparatuses and methods consistent with aspects of the present disclosure as recited in the appended claims.

It should be noted that user information (including but not limited to user equipment information, user personal information, etc.), data (including but not limited to data used for analysis, stored data, displayed data, etc.) and signals involved in this disclosure , are authorized by the user or fully authorized by all parties, and the collection, use and processing of relevant data need to comply with the relevant laws, regulations and standards of the relevant countries and regions. For example, the information carried in the game service request involved in this disclosure is obtained under the condition of sufficient authorization.

In some embodiments, the meaning of A and/or B includes: A and B, A, B these three situations.

Hereinafter, terms related to the embodiments of the present disclosure will be described.

API (Application Program Interface, application program interface): referred to as interface for short, API is defined as a set of standards that applications can use to exchange information and commands with the computer operating system. A standard API provides a common programming environment for users or software developers to write applications that can run interactively on computers from different manufacturers.

Service (Service): Service refers to the computer equipment that requires various services to support various functions, and some services can also be manually turned on or off to achieve the purpose of managing the corresponding functions.

Micro-Service (Micro-Service): A software development technology, which is a variant of the SOA (Service-Oriented Architecture, service-oriented structure) architecture style. It advocates dividing a single application into a set of small services, and the services interact with each other. Coordinate and cooperate with each other to provide users with ultimate value. Each service runs in its own independent process, and the services communicate with each other using a lightweight communication mechanism. The communication mechanism can be RPC (Remote Procedure Call, remote procedure call) or HTTP (Hyper Text Transfer Protocol, hypertext transfer protocol) ) provides RESTful API, etc. Each service is built around a specific business and can be independently deployed to production environments, production-like environments, etc. In addition, a unified and centralized service management mechanism should be avoided as much as possible. For a specific service, an appropriate language and tool should be selected to build it according to the context.

Remote Procedure Call (Remote Procedure Call, RPC): similar to the C/S (Client/Server, client/server) system of the three-tier architecture, the game server requests services from the remote business server through the network, and the game business is usually performed by Provided by the game engine in the game server. In the embodiment of the present disclosure, the service server provides an API to the game server, and the game server calls the API that matches the game service for different game services to remotely call the internal standard or custom function of the service server indicated by the API to obtain the function The returned data is processed and displayed or printed.

Coroutine: Like a subroutine, a coroutine is also a program component. Compared with subroutines, coroutines are more general and flexible. Coroutines are derived from Simula and Modula-2 languages, but are also supported by other languages.

In the following, the system architecture involved in the embodiments of the present disclosure will be described.

Fig. 1 is a schematic diagram of an implementation environment of a game service request processing method according to an embodiment of the present disclosure. Referring to Fig. 1 , the implementation environment includes a terminal 110 and a server cluster 120, and the server cluster 120 includes at least a game server 121 and a server cluster 120. One or more service servers 122. Here, the mail service server 122a, message service server 122b and group service server 122c are taken as examples for illustration.

There are game applications supporting various game services installed and running on the terminal 110. The game can be a mobile game or a PC (Personal Computer, personal computer) game. The game service involves real-time services and non-real-time services, such as in-game player The ray detection when controlling the displacement of the virtual object, the damage judgment when the player controls the interaction of the virtual object, etc. are all real-time services with high real-time requirements, such as IM (Instant Messaging) messages sent by players in the game, player pulling The unread mailing list, etc. are all non-real-time services with low real-time requirements.

Optionally, the above-mentioned game application may be an application natively built into the operating system of the terminal 110, a third-party application independently installed on the terminal 110, or an embedded game program embedded in other applications. The implementation of the game application is not specifically limited. In an example, the game application is also a cloud game application.

Optionally, the game types provided by the game application include: FPS (First-Person Shooting, first-person shooter) games, TPS (Third-Personal Shooting, third-person shooter) games, MOBA (MultiplayerOnline Battle Arena, multiplayer online tactical arena) ) games, survival and construction games, open world games, management and construction games, exploration games, sandbox games, virtual reality applications, 3D map programs or multiplayer survival games, etc. Specific limits.

In some embodiments, the user starts the game application on the terminal 110, and as the user operates in the game application, the terminal 110 is triggered to send a game service request to the server cluster 120, and the game server 121 in the server cluster 120 is the first to receive the game service request. service request, and judge whether to route the game service request to the service server 122 based on the service type indicated by the game service request.

The terminal 110 is directly or indirectly connected to the server cluster 120 through wired or wireless communication, which is not limited in this embodiment of the present disclosure.

The server cluster 120 is used to provide background services for game applications running on the terminal 110, and the server cluster 120 includes at least one of multiple servers, cloud computing platforms, or virtualization centers. Optionally, the server cluster 120 undertakes the main calculation work, and the terminal 110 undertakes the secondary calculation work; or, the server cluster 120 undertakes the secondary calculation work, and the terminal 110 undertakes the main calculation work; or, the server cluster 120 and the terminal 110 adopt distributed Computing architecture for collaborative computing.

The server cluster 120 involves a game server 121 and a business server 122 . Wherein, the game server 121 is used to maintain the main business logic of the game. For example, the GameSvr process is created in the game server 121 to provide the basic gameplay logic of the game. Each game service request from the outside will first be sent to the GameSvr process of the game server 121, and Whether to forward to the service server 122 is decided by the GameSvr process. Among them, the business server 122 can adopt the micro-service organizational structure for development and deployment. For example, various non-real-time services that are originally tightly coupled to the main business logic in the game server 121 are decomposed into several independent small services, and each service is processed separately. For specific business needs, the statelessness of these small services can be ensured through the request/response model, and the microservice architecture can be easily updated and expanded for each service, and can avoid the availability risk in the tightly coupled model.

Optionally, the different non-real-time services split from the main business logic are distributed and deployed in different service servers, for example, the mail service is split and deployed to the mail service server 122a, and the message service is split And deploy to the message service server 122b, split and deploy the group service to the group service server 122c.

In some embodiments, the game server 121 in the server cluster 120 is the first to receive various external game service requests. For each game service request, it is judged whether to route the game service request to the service server 122 based on the service type indicated by the game service request. For example, if the game service associated with the game service request is a real-time service, the game server 121 itself will respond in real time to the game service request; if the game service associated with the game service request is a non-real-time service, the game server 121 will Query the service server that best matches the game service. For example, if the game service is a mail service, the game service request is routed to the mail service server 122a for processing; if the game service is a message service, the game service request is routed to the message service Server 122b performs processing.

In some embodiments, a group service server 122c is also configured in the server cluster 120. If the game service involves group sending of emails, or the message service involves group sending of messages, the mail service server 122a or message service server 122b can communicate with the group The business server 122c sends information messages to pull the latest member list of the specified group, so as to ensure the timeliness of group member updates, avoid pushing wrong messages to members who have left the group, and avoid sending wrong messages to members who have joined the group. Members miss push messages.

In some embodiments, the device types of the terminal 110 include: smart phones, tablet computers, e-book readers, MP3 (Moving Picture Experts Group Audio Layer III, moving picture experts compression standard audio layer 3) players, MP4 (Moving Picture Experts Group Audio Layer IV, motion picture expert compression standard audio layer 4) At least one of player, laptop computer or desktop computer. For example, the terminal 110 is a smart phone, or other handheld portable electronic devices. In the following embodiments, the terminal 110 includes a smart phone as an example for illustration.

Those skilled in the art may know that the number of the foregoing terminals 110 may be more or less. For example, there is only one terminal 110, or there are dozens or hundreds of terminals 110, or more. The embodiment of the present disclosure does not limit the number and device types of terminals 110 .

Fig. 2 is a flow chart of a method for processing a game service request according to an embodiment of the present disclosure. Referring to Fig. 2 , the method for processing a game service request is executed by a computer device. The computer device is used as a game server as an example for illustration.

In step 201, the game server determines the service type of the game service request in response to the game service request of the account, and the service type indicates the timeliness attribute of the game service associated with the game service request.

The game service request involved in the embodiments of the present disclosure refers to the game service request triggered by the user’s operation on the terminal side after the user logs in the account on the terminal game application, and the game service request carries at least the requested game service The service identification (Identification, ID) of the game service and the service parameters matched by the game service. Optionally, the service type of the game service may also be carried in the game service request. Among them, the service ID is used to indicate what kind of service the game service is, the service type is used to indicate whether the timeliness of the game service is real-time service or non-real-time service, and the service parameter is the necessary input for the terminal side to request the game service Related parameters.

In some embodiments, the game server creates a GameSvr process to provide the basic gameplay logic of the game, and each game service request from the outside will first be sent to the GameSvr process, and the GameSvr process parses the game service request, such as parsing the header field of the game service request , get the business ID recorded in the header field, parse the data field of the game business request, get the business parameters recorded in the data field, then query the business type to which the business ID belongs, if the business type is a real-time business, then the GameSvr process To process the game service request, if the service type is non-real-time service, enter the following step 202.

In some other embodiments, the business type is directly carried in the real-time business if the business type is, for example, the business type is encapsulated into the header field of the game service request, and the GameSvr process of the game server parses the header field to obtain the header field Then, if the service type is a real-time service, the game service request is processed by the GameSvr process, and if the service type is a non-real-time service, then enter the following step 202. In some embodiments, the service type may also be encapsulated into the data field of the game service request, which is not specifically limited in this embodiment of the present disclosure.

In step 202, when the service type indicates that the game service is a non-real-time service, the game server determines a service interface matching the non-real-time service.

In some embodiments, when the service type of the game service is a non-real-time service, there is no need for the GameSvr process to spend resources to process the game service request in real time, and the game server can route the game service request to a separate support for the game Processing in the business server of the business can save the processing resources of the game server and optimize the resource allocation of the game server.

In some embodiments, under the framework of decoupling non-real-time services from game servers and independently deploying them to their own service servers, each non-real-time service will be configured with a one-to-one corresponding service API. The API can inject the service parameters of the non-real-time service into the RPC request through the invocation of the GameSvr process, and send the RPC request to the service server indicated by the service API.

In some embodiments, the game server queries the service API associated with the service ID of the non-real-time service based on the service ID of the non-real-time service. Or, based on the business name of the non-real-time business, the game server queries the service API associated with the business name of the non-real-time business. The embodiment of the present disclosure does not specifically limit whether the service API is stored corresponding to the business name or business ID.

In step 203, the game server queries the address of the business server for providing the service interface from the service registration center, and the service registration center is used to record the addresses of the business servers of various interfaces.

In some embodiments, whenever a non-real-time business is decoupled from the game server, the service API of the non-real-time business and the address of the corresponding business server will be registered in the service registration center, that is, The mapping relationship between each pair of service API and the address of the business server will be recorded in the service registry. Optionally, the above-mentioned mapping relationship is stored in a hash table, linked list, dynamic array, Key-Value (key-value pair) data structure, etc., which will not be described in detail here.

In some embodiments, after the game server queries the service API of the current game business based on step 202, it queries the mapping relationship in the service registration center to obtain the address of the service server for providing the service API. Optionally, The address includes an IP (Internet Protocol, Internet Protocol) address and communication port.

In step 204, the game server sends an RPC request to the address based on the service interface, and the RPC request is used to instruct the service server to provide the account with a response to the game service.

In some embodiments, the game server invokes the service API, injects the service parameters parsed from the game service request into the service API, then, the service API encapsulates the RPC request based on the injected service parameters, and forwards the RPC request to The address obtained by querying in step 203 implements a scheme of initiating a game service request to the service based on the RPC framework.

In some embodiments, under the microservice framework, for each non-real-time business service API (which can be regarded as a microservice interface), a separate service server is configured for it, and the database clusters between different service servers are mutually Independent and environment-isolated, ensuring that the database operation of a non-real-time business will not affect other non-real-time businesses, ensuring that different services are independent of each other and no longer tightly coupled, and avoiding the failure of a certain service in the case of tight coupling. The cascading problem of faults, under this type of microservice framework, even if a service fails, only a single service will be unavailable, and it will not affect the normal functions of other services, which greatly improves the overall availability of services.

In the method provided by the embodiment of the present disclosure, for the game service request requesting non-real-time service, since the real-time requirement is not high, there is no need for the game server to perform real-time processing locally, so that the service registration center can be found that is dedicated to processing the non-real-time service. service API, and then make RPC remote call to the remote business server through the service API, so that the user load related to non-real-time business can be migrated from the game server to the business server, and the resource configuration of the game server is optimized. The iteration and update of non-real-time business only needs to modify the code logic in the business server, and modify the service API if necessary, which does not involve patching the main business logic of the game, which reduces the development complexity and improves the game development efficiency. The non-real-time business can be deployed separately in different business servers, so that when some business functions are blocked, it will not affect the normal use of other business functions, and will not affect the main business logic of the game, which greatly improves the usability of the game .

In some embodiments, querying the address of the service server for providing the service interface from the service registry includes:

From the service registry, query the set of addresses used to provide the service interface;

From the address set, query the address of the business server with the closest geographic distance to the account.

In some embodiments, the method also includes:

Create a coroutine for the non-real-time business in response to the RPC request through the business server;

Initiate the database operation of the non-real-time business through the coroutine;

Before obtaining the operation result of the database operation, block and suspend the coroutine;

After the operation result of the database operation is obtained, a response generated based on the operation result is returned.

In some embodiments, the game service request is a mailing list pull request; initiating the database operation of the non-real-time service through the coroutine includes:

Through this coroutine, obtain the maximum personal email sequence number and the maximum system email sequence number in the pulled emails of the account from the mailing list pull request;

Based on the maximum personal email serial number, initiate a batch read operation of personal emails to the personal email collection of the account in the database. The batch read operation is used to read multiple personal emails whose email serial numbers are greater than the maximum personal email serial number mail;

Based on the maximum system mail serial number, a batch read operation of system mail is initiated to the system mail collection of the database, and the batch read operation is used to read multiple system mails whose mail serial numbers are greater than the maximum system mail serial number.

In some embodiments, the game service request is a mailing list pull request; initiating the database operation of the non-real-time service through the coroutine includes:

Use this coroutine to obtain the maximum email sequence number in the pulled emails of the account carried in the mailing list pull request;

Based on the maximum mail sequence number, a batch read operation of system mail is initiated to the system mail collection of the database, and the batch read operation is used to read multiple system mails whose mail sequence numbers are greater than the maximum mail sequence number;

storing the plurality of system emails in the personal email collection of the account in the database;

Based on the maximum mail sequence number, a batch read operation of mails is initiated to the personal mail collection, and the batch read operation is used to read a plurality of mails whose mail sequence numbers are greater than the maximum mail sequence number.

In some embodiments, the method also includes:

Determine the number of unread emails based on the multiple emails returned by the operation result of the batch read operation;

Extracting information summaries of the plurality of emails, where the information summaries are used to provide at least one of the following: email type, email title, sender information, email timestamp and whether it contains attachments;

A response is generated with a digest of the message and an unread count for the message.

In some embodiments, the method also includes:

When the number of multiple mailing list pull requests received in the same time period exceeds the request volume threshold, the service server caches multiple RPC requests associated with the multiple mailing list pull requests into the message queue;

In the message queue, merge the RPC requests associated with the same mailing list pull request sent multiple times by the same initiating account, and configure the request times variable for the initiating account;

Reordering each RPC request in the message queue based on the request times variable;

At least one RPC request in the current batch in the reordered message queue is processed in batches at each target time interval.

In some embodiments, the game service request is a pull request for email details; initiating the database operation of the non-real-time service through the coroutine includes:

Determine the email type and email serial number requested by the email details pull request through this coroutine;

Initiate a read operation of the mail indicated by the serial number of the mail to the mail set indicated by the mail type in the database, the read operation is used to read the mail body of the mail, and if the mail carries an attachment Also read the attachment.

In some embodiments, the game service request is an email sending request; initiating the database operation of the non-real-time service through the coroutine includes:

Determine the mail type of the mail to be sent indicated by the mail sending request through the coroutine;

In the case that the email type is a personal email, initiate a write operation to the email to be sent to the personal email collection of the account in the database;

In the case that the mail type is a system mail, a write operation of the mail to be sent is initiated to the system mail collection of the database.

In some embodiments, the method also includes:

Based on the operation result of the write operation, assign a mail serial number to the mail to be sent;

When the recipient account of the email to be sent is offline in the game, generate a response to notify the account that the email is sent successfully;

When the recipient account of the email to be sent is in the game online state, generate a response to notify the account that the email is successfully sent; and generate a response to push the email to the recipient account.

In some embodiments, the game service request is an unread message pull request; initiating the database operation of the non-real-time service through the coroutine includes:

Through the coroutine, the account to be queried and the maximum message ID are obtained from the unread message pull request, and the maximum message ID indicates the latest read message in the session between the account and the account to be queried;

Based on the maximum message ID, initiate a batch read operation of unread messages to the message set of the account and the account to be queried in the database, and the batch read operation is used to read multiple messages whose message ID is greater than the maximum message ID .

In some embodiments, the method also includes:

Determine the number of unread messages based on the multiple messages returned by the operation result of the batch read operation;

A response carrying the plurality of unread messages and the number of unread messages is generated.

In some embodiments, the game service request is a message sending request; initiating the database operation of the non-real-time service through the coroutine includes:

Determine the message type of the message to be sent indicated by the message sending request through the coroutine;

In the case that the message type is a personal message, initiate a write operation of the message to be sent to the message set of the account and message receiving account in the database;

In the case that the message type is a group message, a write operation of the message to be sent is initiated to the message collection of the message receiving group in the database.

In some embodiments, the method also includes:

Based on the operation result of the write operation, assign a message identifier to the message to be sent, and generate a response to notify the account that the message is successfully sent;

For the personal message, only when the message receiving account is in the online state of the game, generate a response to push the message to be sent to the message receiving account;

For the group message, the latest member list of the message receiving group is pulled; only for the online member account in the latest member list, a response of pushing the message to be sent to the online member account is generated.

In some embodiments, the game service request is an account addition request, and the account addition request is used to apply for adding the target account to the account relationship chain of the account; the database operation of initiating the non-real-time service through the coroutine includes:

Through this coroutine, verify the authority of the account;

After the verification is passed, initiate a database operation to write the record added by the account to the account of the target account to the database;

After obtaining the operation result of the database operation, the response generated based on the operation result includes:

When the operation result indicates that the account addition record has been written, an account addition notification response to the target account is generated.

All the above optional technical solutions may be combined in any way to form optional embodiments of the present disclosure, which will not be repeated here.

Fig. 3 is an interactive flow chart of a method for processing a game service request according to an embodiment of the present disclosure. Constituting a server cluster for externally providing game services, and both the game server and the service server are exemplary illustrations of computer equipment, this embodiment includes the following steps.

In step 301, the game server determines the service type of the game service request in response to the game service request of the account.

Wherein, the service type indicates the timeliness attribute of the game service associated with the game service request.

In some embodiments, the game server creates a GameSvr process to provide the basic gameplay logic of the game, and each game service request from the outside will first be sent to the GameSvr process, and the GameSvr process parses the game service request.

Optionally, the game service request carries a service ID and service parameters, and the GameSvr process parses the header field of the game service request to obtain the service ID recorded in the header field, parses the data field of the game service request, and obtains the data field recorded in the data field. business parameters.

In this case, the game server side can record the mapping relationship between business ID and business type, and the mapping relationship is stored in the form of hash table, linked list, dynamic array, Key-Value data structure, etc., which will not be described here. After parsing the business ID from the header field, query the mapping relationship between the above business ID and business type to obtain the business type to which the business ID belongs. Wherein, the service type is used to indicate the timeliness attribute of the game service indicated by the service ID in terms of timeliness, for example, the service type includes real-time service and non-real-time service.

Optionally, the game service request carries service ID, service type and service parameters, and the GameSvr process parses the header field of the game service request, obtains the service ID and service type recorded in the header field, and parses the data field of the game service request, Obtain the business parameters recorded in the data field; or, the GameSvr process parses the header field of the game business request, obtains the business ID recorded in the header field, parses the data field of the game business request, and obtains the business type and business recorded in the data field parameter.

In an example, the header field or data field of the game service request carries a Real-Time (real-time) variable, and the Real-Time variable is used to indicate the service type of the game service. Optionally, the Real-Time variable is a binary variable, If the value of the Real-Time variable is 0, it means that it is a non-real-time service. If the value of the Real-Time variable is 1, it means that it is a real-time service. If the value of the Real-Time variable is default, it can be regarded as the default value. , which is pre-configured on the game server side by technicians. Or, the Real-Time variable is a Boolean variable. If the value of the Real-Time variable is False, it means that it is a non-real-time service. If the value of the Real-Time variable is True, it means that it is a real-time service. The default value is False or True, which is pre-configured by the technician on the game server side.

In another embodiment, the Real-Time field is set in the header field or data field of the game service request, or the Real-Time field is set between the header field and the data field, and the Real-Time field is used to record the business type, so The business type can be obtained by parsing the Real-Time field. For example, the business type recorded in the Real-Time field is a string variable. When the value of the string variable is "Real-Time", it indicates a real-time service. "Non-Real-Time" indicates a non-real-time service, or the service type recorded in the Real-Time field is the above-mentioned binary variable or Boolean variable, which is not specifically limited in this embodiment of the present disclosure.

In some embodiments, if the service type obtained by the game server is a real-time service, the game service request is processed by the GameSvr process; if the service type is a non-real-time service, then enter the following step 302 .

In step 302, when the service type indicates that the game service is a non-real-time service, the game server determines a service interface matching the non-real-time service.

In some embodiments, when the service type of the game service is a non-real-time service, there is no need for the GameSvr process to spend resources to process the game service request in real time, and the game server can route the game service request to a separate support for the game Processing in the business server of the business can save the processing resources of the game server and optimize the resource allocation of the game server.

In some embodiments, under the framework of decoupling non-real-time services from game servers and independently deploying them to their own service servers, each non-real-time service will be configured with a one-to-one corresponding service API. The API can inject the service parameters of the non-real-time service into the RPC request through the invocation of the GameSvr process, and send the RPC request to the service server indicated by the service API.

In some embodiments, the game server queries the service API associated with the service ID of the non-real-time service based on the service ID of the non-real-time service. Or, based on the business name of the non-real-time business, the game server queries the service API associated with the business name of the non-real-time business. The embodiment of the present disclosure does not specifically limit whether the service API is stored corresponding to the business name or business ID.

In step 303, the game server queries the address of the service server for providing the service interface from the service registration center.

Wherein, the service registration center is used to record the addresses of service servers of various interfaces.

In some embodiments, whenever a non-real-time business is decoupled from the game server, the service API of the non-real-time business and the address of the corresponding business server will be registered in the service registration center, that is, The mapping relationship between each pair of service API and the address of the business server will be recorded in the service registry. Optionally, the above-mentioned mapping relationship between the service API and the address of the business server is stored in a hash table, linked list, dynamic array, Key-Value data structure, etc., which will not be described here.

In some embodiments, after the game server queries the service API of the current game business based on step 302, it queries the mapping relationship in the service registration center to obtain the address of the service server for providing the service API. Optionally, The address includes an IP (Internet Protocol, Internet Protocol) address and communication port.

In some embodiments, the service server deployed for the same non-real-time service is not a single server, but a plurality of servers deployed in various places using a CDN (Content Delivery Network, content distribution network) architecture. In this case, When each service API is registered in the above-mentioned service registration center, it records the address set formed by each service API and a group of respective addresses of the business servers. On this basis, the game server queries the address set used to provide the service API from the mapping relationship of the service registry, and then, since the address set records the respective addresses of a group of business servers, the game server can obtain from In this address set, query the address of the business server with the closest geographical distance to the account. For example, if the user is fully authorized, determine the IP region of the account and find the address of the business server with the same IP region in the address set. , if there are multiple addresses of business servers in the same IP domain, select the address of the business server with the closest geographical distance; The address of the service server with the closest geographic distance is found from the addresses of the service servers of the given service server, which is not specifically limited in this embodiment of the present disclosure.

Optionally, CDN architecture is used for distributed deployment of service servers only for some relatively busy non-real-time services, and a service server is used for independent deployment of the remaining relatively idle non-real-time services, or CDN architecture is used for all non-real-time services Distributed deployment of service servers, or all non-real-time services are independently deployed by a service server, and the embodiment of the present disclosure does not specifically limit the deployment mode of the service server.

In the above process, through the distributed deployment of CDN architecture for some or all non-real-time services, the game service request of each account can be routed from the game server to the business server with the closest geographical distance according to the principle of proximity, and the closest geographical distance The business server provides the non-real-time business, greatly speeding up the processing efficiency and response speed of the non-real-time business.

In step 304, the game server sends an RPC request to the address of the business server based on the service interface.

Wherein, the RPC request is used to instruct the service server to provide the account with a response to the game service.

In some embodiments, the game server invokes the service API, injects the service parameters parsed from the game service request into the service API, then, the service API encapsulates the RPC request based on the injected service parameters, and forwards the RPC request to The address obtained by querying in step 303 implements a scheme of initiating a game service request to the service based on the RPC framework.

In some embodiments, under the microservice framework, for each non-real-time business service API (which can be regarded as a microservice interface), a separate service server is configured for it, and the database clusters between different service servers are mutually Independent and environment-isolated, ensuring that the database operation of a non-real-time business will not affect other non-real-time businesses, ensuring that different services are independent of each other and no longer tightly coupled, and avoiding the failure of a certain service in the case of tight coupling. The cascading problem of faults, under this type of microservice framework, even if a service fails, only a single service will be unavailable, and it will not affect the normal functions of other services, which greatly improves the overall availability of services.

Furthermore, both the service registry and the RPC framework can be directly supported by the original game engine in the game server, and the service API can combine stateless RPC requests for non-real-time services with stateful game services for real-time services by encapsulating RPC requests. Requests are isolated. Here, stateful and stateless refer to whether a state machine (State Machine) needs to be maintained during business processing.

For example, for real-time services with high real-time requirements, such as real-time skill casting, damage statistics, ray detection, in-game microphone connection, etc., it is necessary to maintain a player client-game server-player client for such real-time services Therefore, it is necessary to maintain a state machine to handle stateful game service requests. This type of real-time service is processed and responded by the GameSvr process of the game server; for non-real-time services with low real-time requirements, such as non-real-time Mail service, message service, friend service, leaderboard service, etc., each time the terminal needs to access non-real-time services, it encapsulates the service parameters of the non-real-time service into the game service request, and after sending the game service request to the game server, the terminal You can continue to perform other operations and wait for the business server to return a response directly, or the business server will call back to notify the game server after generating a response, and then the game server will return a response to the terminal, which means that non-real-time services will not block the game thread on the terminal side. It does not block the GameSvr process on the game server side, but splits the non-real-time business from the overall architecture. Through the implementation of the micro-service architecture, it can optimize the resource allocation of the server cluster and improve the availability of the game business. In the following steps 305-308, the processing flow at the service server side will be described in detail.

In step 305, the service server creates a coroutine for the non-real-time service in response to the RPC request.

In some embodiments, a coroutine is developed on the business server side. In the coroutine development, the business server creates a new coroutine for each RPC request, and the non-real-time business associated with the RPC request involves database operations (such as reading operation, or write operation), triggers to block the current coroutine, so that the blocking of the current coroutine will not affect the operation of the main thread on the business server. If there are multiple coroutines involved in database operations at the same time and enter the blocking state In the case of , the main thread selects one of the existing coroutines to execute, and the blocked coroutine will be suspended until the main thread selects itself as the execution unit and obtains the execution result of the database operation.

In the above process, through the development of coroutines, when controlling the CPU (Central Processing Unit, central processing unit) to schedule database resources, the overhead of coroutines is smaller than that of threads, which can save the processing resources of business servers.

In some embodiments, a main thread is maintained on the service server, and the main thread responds to the RPC request sent by the service API in step 304, parses the RPC request, obtains the service parameters of the non-real-time service, and judges whether the non-real-time service Involving database operations, if the non-real-time business involves database operations, create a coroutine for the non-real-time business.

Optionally, when creating a coroutine, create a gevent coroutine based on python's third-party coroutine library gevent, because the gevent coroutine can have its own event loop, and when the main thread executes to the function that blocks the current coroutine, it will find Other executable coroutines can simplify the difficulty of development, or other methods can also be used to create other types of coroutines, and the type of coroutines created is not specifically limited here.

In step 306, the service server initiates the database operation of the non-real-time service through the coroutine.

In some embodiments, when the non-real-time business involves database operations, the business server performs SQL (Structured Query Language, Structured Query Language) analysis based on the business parameters of the non-real-time business through the main thread or coroutine, The SQL statement of the transaction is obtained. The above-mentioned transaction refers to the transaction created to realize the database operation involved in the non-real-time business. The database operation here involves two types of read operation and write operation. After obtaining the SQL statement of the transaction, it is considered that the database operation of the non-real-time business has been initiated, but since the main thread may have multiple coroutines waiting to be processed at the same time, to ensure the consistency of the database, usually It is necessary to add a lock to each data record operated by the currently awakened coroutine. If the added lock is a shared lock, other coroutines that apply for a shared lock can be processed in parallel. If the added lock is an exclusive lock, you can only wait After the current coroutine is processed and the lock is released, other coroutines that apply for the lock of this data record can be woken up. Therefore, after generating the SQL statement of the transaction, the coroutine caches the SQL statement of the transaction, blocks the current transaction, suspends the coroutine, and waits for the main thread to wake up the coroutine.

In step 307, the service server blocks and suspends the coroutine before obtaining the operation result of the database operation.

In some embodiments, before the main thread of the business server wakes up the current coroutine, the coroutine will always be in a suspended state, and needs to block the transaction. The SQL statement executes the database operation on the data records involved in the operation of the SQL statement in the underlying database, and waits for the underlying database to return the operation result of the database operation. Optionally, the underlying database is a Mango database, a Redis storage cluster, or a database of other architectures, which is not specifically limited in this embodiment of the present disclosure.

In step 308, after obtaining the operation result of the database operation, the service server returns a response generated based on the operation result.

In some embodiments, the operation result of the underlying database on the database operation includes: transaction commit or transaction rollback. If the operation result is transaction commit, it means that the database operation has been completed and has been placed on the disk, and a successful response to the operation of the non-real-time business needs to be returned. , and in the case of needing to return business data, further obtain business data based on the data read or written by the SQL statement, encapsulate the business data into the above operation success response, and return the operation success response if there is no need to return business data It can be implemented as an ACK (Acknowledge Character) message; if the operation result is a transaction rollback, it means that the database operation fails to execute and the transaction rolls back, and the operation failure response to the non-real-time business needs to be returned. For example, the operation failure response is provided It is a string of error codes, or an instruction carrying an operation failure flag, which is not specifically limited in this embodiment of the present disclosure.

In some embodiments, after the service server generates the above-mentioned response to the non-real-time service (operation success response or operation failure response), the service server directly returns the above-mentioned response to the terminal, which can save communication overhead, or, the service server uses the service API , return the above response to the game server, so that the game server sends the above response to the terminal, which can reduce the perception of the terminal, ensure that the terminal is not aware of the business server, and the microservice framework is transparent to the user side.

In the method provided by the embodiment of the present disclosure, for the game service request requesting non-real-time service, since the real-time requirement is not high, there is no need for the game server to perform real-time processing locally, so that the service registration center can be found that is dedicated to processing the non-real-time service. service API, and then make RPC remote call to the remote business server through the service API, so that the user load related to non-real-time business can be migrated from the game server to the business server, and the resource configuration of the game server is optimized. The iteration and update of non-real-time business only needs to modify the code logic in the business server, and modify the service API if necessary, which does not involve patching the main business logic of the game, which reduces the development complexity and improves the game development efficiency. The non-real-time business can be deployed separately in different business servers, so that when some business functions are blocked, it will not affect the normal use of other business functions, and will not affect the main business logic of the game, which greatly improves the usability of the game .

All the above optional technical solutions may be combined in any way to form optional embodiments of the present disclosure, which will not be repeated here.

In the previous embodiment, it is briefly introduced how the game server and the business server interact to migrate the game business request of the non-real-time business to the business server for processing, so as to alleviate the load pressure of the game server and improve the performance of a single non-real-time service. Fault cascading problems caused by real-time services. In the following several embodiments, the details of the processing flow of the service server will be introduced by taking two specific service scenarios of email service scene and chat service scene as examples, which will be described below.

(1) Mailing list pull business

Fig. 4 is a processing flowchart of a mailing list pulling service provided by an embodiment of the present disclosure. The processing method is executed by a business server, and the business server may be an integrated server for processing various non-real-time businesses, or a separately deployed mail business server, wherein the business server is an exemplary description of computer equipment.

It should be noted that here only the game server sends the RPC request corresponding to the mailing list pull request to the business server, and the processing flow after the business server creates the coroutine is described, that is, the solution of the embodiment of the present disclosure is based on the previous implementation For the realization after step 305 in the example, how to send the RPC request from the game server to the business server, and how the business server creates a coroutine, please refer to the description of the previous embodiment, and will not go into details.

In some embodiments, there are two types of emails involved in the game: personal emails and system emails. Personal emails refer to emails sent from players to players (ie, game account to game account), and system emails are sent by the game system or game management. Optionally, the business server assigns different mail serial numbers to personal mail and system mail, and keeps the serial numbers of each mail in increments, or, the business server side assigns personal mail and system mail The system mail adopts uniformly coded mail serial numbers and keeps the mail serial numbers incremented. For these two different mail serial number distribution methods, the mailing list pulling process on the business server side is also different, and the following will explain them separately.

Situation 1: Individual emails and system emails are coded separately

In the case of separate encoding of personal mail and system mail, each personal mail has a uniquely identified personal mail serial number, and each system mail also has a uniquely identified system mail serial number. The personal mail serial number and the system mail serial number can be Allocation is based on the same or different encoding methods, and the serial number of personal mail and the serial number of system mail keep increasing.

In step 306-A1, the business server obtains the maximum personal email sequence number and the maximum system email sequence number in the pulled emails of the account carried in the email list pull request through the coroutine.

In some embodiments, when personal emails and system emails are coded separately, when the terminal side initiates a mailing list pull request, it will determine the maximum personal email serial number and The maximum system email serial number, for example, encapsulate the above-mentioned maximum personal email serial number and maximum system email serial number as business parameters into the mailing list pull request, and after the game server parses the above business parameters, inject the above business parameters into the email Service API, the mail service API initiates an RPC request to the business server, and the RPC request carries the business parameters injected in the above mail service API, so that after the business server creates a coroutine, the coroutine can pass the business parameters provided by the mail service API , get the maximum personal mail sequence number and the maximum system mail sequence number.

In the above process, since the terminal side will provide the maximum serial numbers of the two types of emails that have been pulled in the mailing list pull request, the business server can directly read the maximum serial number of personal emails passed in the mail service API and the maximum system email serial number, the business server does not need to perform secondary analysis on the mailing list pull request, which can save the processing resources of the business server.

In step 306-A2, based on the maximum personal mail serial number, the business server initiates a batch read operation of personal mail to the personal mail collection of the account in the database, and obtains multiple mails whose serial number is greater than the maximum personal mail serial number personal mail.

Wherein, the batch read operation is used to read multiple personal emails whose serial numbers are greater than the maximum serial number of personal emails.

In some embodiments, the database involved in the embodiments of the present disclosure refers to a mail database, and the mail database may be a Mango database, an SQL database or other types of databases, and the database type is not specifically limited here. Optionally, a global system mail collection is maintained in the mail database for storing all system mails, and each account also maintains its own personal mail collection for storing all personal mails of the account.

In some embodiments, in the case where the mail database is maintained separately on the service server side, after the maximum personal mail serial number is obtained through step 306-A1, the personal mail of the account is queried using the account ID of the account as an index. Collection, the personal mails in the personal mail collection are arranged in descending order of the mail serial number, and then read backwards from the personal mail next to the latest read personal mail indicated by the largest personal mail serial number , until there is no new personal mail that can be read, all personal mails with mail serial numbers greater than the maximum personal mail serial number can be obtained.

In step 306-A3, based on the maximum system mail serial number, the business server initiates a batch read operation of system mails to the system mail collection in the database, and obtains multiple system mails whose mail serial numbers are greater than the maximum system mail serial number.

Wherein, the batch read operation is used to read multiple system mails whose mail serial numbers are greater than the maximum system mail serial number.

In some embodiments, in the case where the mail database is maintained separately on the service server side, after the maximum system mail serial number is obtained through step 306-A1, the system mail collection in the mail database is queried, and the system mail collection in the system mail collection Mails are arranged in descending order of mail sequence numbers, and then read backwards from the next system mail indicated by the latest read system mail number, until there is no new one to read system mail, you can get all the system mails whose mail sequence number is greater than the maximum system mail sequence number.

In the above process, only the case where the mailing list pull request instructs the business server to obtain all personal emails and all system emails that have not been pulled is used as an example. In some embodiments, it is assumed that after the account is switched to the device, the newly switched The terminal may have a lot of emails that have not been fetched. If you get all the emails that have not been fetched at once, the response speed is likely to be very slow. Therefore, the user can choose to fetch only the last 50, the last 100, and the last 200, etc. You can add the business parameter of the number of emails to be pulled in the mailing list pull request. In this case, you can find all the emails that have not been pulled and then select the latest multiple emails that meet the number of emails to be pulled.

In the above step 306-A1 to step 306-A3, a possible implementation mode for the business server to initiate the database operation of the non-real-time business through the coroutine is provided, that is, in the case of separate encoding of the personal mail and the system mail, respectively according to The maximum personal mail sequence number to initiate a batch read operation from the personal mail collection, and initiate a batch read operation from the system mail collection according to the maximum system mail sequence number.

In this way of encoding personal emails and system emails separately, only one read operation is required for each unfetched system email and each unfettered personal email, that is, the system email is read from the system email collection , to read personal emails from the personal email collection, which does not involve the backup of system emails (not to mention the reordering during backup), so the overhead of database operations is small, and the transaction execution efficiency is high, but the emails are carried in the business parameters In the case of pulling the quantity, due to the need to compare the size of the personal message sequence number and the system message sequence number, it may slightly increase the calculation overhead.

Situation 2: Uniform encoding of personal emails and system emails

In some other embodiments, it also provides a way to uniformly encode personal emails and system emails, so that the serial numbers of personal emails and system emails will no longer be distinguished, and each personal email or system email will be assigned a unique email serial number , and keep the message sequence number globally incremented.

In step 306-B1, the business server obtains the largest email serial number among the pulled emails of the account carried in the email list pull request through the coroutine.

In some embodiments, in the case of uniform encoding of personal emails and system emails, when the terminal side initiates a mailing list pull request, it will determine the largest email sequence number in the pulled emails of the account currently logged into the game application, such as , encapsulate the above maximum email serial number as a business parameter into the mailing list pull request, after the game server parses the above business parameters, inject the above business parameters into the mail service API, and the mail service API initiates an RPC request to the business server, The RPC request carries the business parameters injected in the mail service API above, so that after the business server creates a coroutine, the coroutine can obtain the maximum mail serial number through the business parameters provided by the mail service API.

In the above process, since the terminal side will provide the global maximum mail serial number in the mailing list pull request, the business server can directly read the maximum mail serial number incoming in the mail service API, without requiring the business server to update the mailing list. The secondary analysis of the pull request can save the processing resources of the business server.

In step 306-B2, the business server initiates a batch read operation of system mails to the system mail collection in the database based on the maximum mail serial number, and obtains multiple system mails whose mail serial numbers are greater than the maximum mail serial number.

Wherein, the batch read operation is used to read multiple system emails whose email sequence numbers are greater than the maximum email sequence number.

In some embodiments, the database involved in the embodiments of the present disclosure refers to a mail database, and the mail database may be a Mango database, an SQL database or other types of databases, and the database type is not specifically limited here. Optionally, a global system mail collection is maintained in the mail database for storing all system mails, and each account also maintains its own personal mail collection for storing all personal mails of the account.

In some embodiments, in the case where the mail database is maintained separately on the service server side, after the maximum mail serial number is obtained through step 306-B1, the system mail collection in the mail database is queried, and the system mail collection in the system mail collection Arranged in descending order of mail sequence numbers, and then read backwards from the next system mail of the latest read system mail indicated by the largest mail sequence number until there is no new readable system mail Mail, you can get all the system mails whose mail serial number is greater than the maximum mail serial number.

In step 306-B3, the service server stores the multiple system emails into the personal email collection of the account in the database.

In some embodiments, in order to facilitate batch reading of emails, in the case of uniform encoding of personal emails and system emails, the business server reads all system emails with email serial numbers greater than the maximum email serial number based on step 306-B2 , you can also use the account ID of the account as an index to locate the personal mail collection of the account in the mail database, and store all system mails with the serial numbers of the above mails greater than the maximum mail serial number into the personal mail collection of the account , so that it is convenient to scan all the unfetched emails in the personal mail collection at one time.

In some embodiments, when the service server stores all system mails in the personal mail collection, it needs to store them sequentially according to the serial numbers of the mails in ascending order, that is, to ensure that after all system mails are stored in the personal mail collection, All the mails in the personal mail collection are still stored in the increasing order of the mail serial number (not out of order). Specifically, when storing each system mail, the service server finds the target mail whose serial number is the closest to and does not exceed the current system mail in the personal mail collection, and inserts the current system mail after the target mail ( Next to the target mail), that is, it can ensure that the system mail will not be out of order when stored.

In some other embodiments, after storing all system mails in the personal mail collection, the service server reorders the personal mail collection according to the sequence number of the mail from small to large, so that there is no need to consider whether the order is out of order when storing, but Resource overhead due to the need to reorder individual mail collections.

In step 306-B4, the service server initiates a batch read operation of mails to the personal mail collection based on the maximum mail serial number, and obtains multiple mails with mail serial numbers greater than the maximum mail serial number.

Wherein, the batch read operation is used to read a plurality of mails whose serial numbers are greater than the maximum mail serial number.

In some embodiments, after the service server stores all system emails with email sequence numbers greater than the maximum email sequence number into the account's personal mail collection, all mails (personal mail and system mail) in the personal mail collection are When the mail sequence numbers are arranged in descending order, read backwards from the next mail of the latest read mail indicated by the largest mail serial number until there are no new readable mails. You can get all the mails whose mail serial numbers are greater than the maximum mail serial number.

In the above process, only the case where the email list pull request indicates that the service server has obtained all emails that have not been pulled is taken as an example. In some embodiments, it is assumed that after the account is switched, the newly switched terminal may have many Pulled emails, if you get all the emails that have not been pulled at one time, the response speed is likely to be very slow, so the user can choose to pull only the last 50, last 100, last 200, etc., at this time can be found in the mailing list Add the business parameter of the number of emails to be pulled in the pull request. In this case, you can find all the emails that have not been pulled and select the latest multiple emails that meet the number of emails to be pulled, or directly add the serial number of the email After all system emails with a serial number greater than the maximum email number are stored in the personal mail collection of the account, read from the latest mail in the personal mail collection (referring to the mail with the largest mail serial number) in order, until it reads the mail that matches the pull Stop reading when fetching multiple messages.

In the above step 306-B1 to step 306-B4, a possible implementation mode for the business server to initiate the database operation of the non-real-time business through the coroutine is provided, that is, in the case of uniform encoding of personal mail and system mail, first follow the The maximum email serial number, find all system emails that have not been pulled from the system email collection, store all the system emails that have not been pulled into the personal mail collection in order, and then perform batch read operations from the personal mail collection again.

This method of uniform encoding of personal emails and system emails facilitates reading directly from the latest emails in the case of carrying the number of emails pulled in the business parameters, which can improve the efficiency of only obtaining some unpull emails. However, due to the need to batch read all the system emails that have not been pulled and store them in the personal email collection, and then need to re-read some or all of the backed up system emails in the personal email collection when batch reading, it is necessary to perform the above backup The latter system mail performs two read operations, and its database operation is slightly more expensive.

Fig. 5 is the logical structural diagram of the mail database in a kind of business server that the embodiment of the present disclosure provides, as shown in Fig. 5, in the mail service (Mail Service) system 500, is configured with mail database 510, optionally, mail database 510 is realized with Mango database. The global system mail (global_mail) collection 511 and the personal mail (personal_mail) collection 512 of each account are maintained in the mail database 510, and the personal mail of each account is stored in the personal mail collection 512 of the account, and sent by the whole server The system mails are uniformly stored in the system mail collection 511 .

In the way that personal emails and system emails are encoded separately, each personal email in the personal email collection 512 maintains an auto-incrementing personal email serial number personal_mailID, and each system email in the system email collection 511 maintains an auto-incrementing system email serial number global_mailID, personal_mailID and global_mailID can be encoded in the same or different ways. In this case, all unfetched emails can be read based on the manner of steps 306-A1 to 306-A3.

In the manner of uniform encoding of personal mails and system mails, each personal mail in the personal mail collection 512 and each system mail in the system mail collection 511 jointly maintain a self-incrementing mail serial number mailID. In this case, all unpulled emails can be read based on the manner of step 306-B1 to step 306-B4.

The above two cases provide two possible implementation methods for the business server to initiate non-real-time business database operations through coroutines under different encoding methods of mail serial numbers. Through the above methods, batch reading of mail databases can be initiated At this time, step 307 in the previous embodiment can still be executed, that is, block the coroutine when the operation result of the database operation is not obtained, and then, when the operation result of the database operation is obtained, if the operation result indicates that the transaction commits ( Instead of transaction rollback), the following steps 401-403 are performed:

In step 401, the service server determines the number of unread emails based on the multiple emails returned by the operation result of the batch read operation.

In some embodiments, after the business server executes the batch read operation on the unpulled emails through any of the above possible implementation modes, if the operation result of the batch read operation indicates that the transaction is committed, it can obtain the batch For the multiple emails that have been read, count the number of multiple emails read in batches above to obtain the number of unread emails.

In step 402, the service server extracts information summaries of the multiple emails, and the information summaries are used to provide at least one of the following: email type, email title, sender information, email time stamp, and whether the email contains attachments.

Wherein, the mail type is used to indicate whether the mail is a personal mail or a system mail.

Wherein, the sender information refers to relevant information of the sender of the email, for example, the relevant information includes at least one of the sender's account nickname, account ID, and account profile picture in the game.

Wherein, the email timestamp refers to the sending timestamp when the email sender sends the email.

Among them, whether there are attachments is used to indicate whether the mail contains attachments. It can be a binary variable or a Boolean variable. When the value of the binary variable is 1 or the value of the Boolean variable is True, it indicates that the mail contains attachments. A Value variable of 0 or a Boolean variable of False indicates that the message contains no attachments.

In some embodiments, when multiple emails are read in batches, if all emails are returned to the terminal at one time, on the one hand, the communication overhead of data transmission is large and occupies a lot of bandwidth; on the other hand, the efficiency of data transmission is low, and the terminal needs to wait for a long time to receive a response. In view of this, the business server can extract the information summary of the multiple emails read in batches above, for example, extract the email type, email title, sender information, email timestamp and whether it contains at least one of the attachments of each email , the information summary (mailInfo) that makes up this email, when generating a response to the mailing list pull request, can only carry the information summary of each email read in batches, without carrying the specific email body (if the email contains attachments In this case, no attachments are carried), which can greatly save the communication overhead during transmission of the above responses, save the bandwidth occupied by response transmission, improve data transmission efficiency and response efficiency to mailing list pull requests.

In some embodiments, when extracting the information summary of each email, it is judged whether the sender of the email is a game administrator or a game system, and then the email type is assigned as a system email; otherwise, the email type is assigned as a personal email , and write the assigned mail type into the message summary of the mail.

In some embodiments, when the information summary of each email is extracted, the email title of the email is extracted, and the extracted email title is written into the email information summary in the form of a character string.

In some embodiments, when extracting the information summary of each email, extract at least one of the sender's account nickname, account ID, and account avatar in the game, and write the extracted sender information to into the message digest of the email.

In some embodiments, when the information summary of each email is extracted, the sending timestamp of the email sent by the sender of the email is extracted, and the extracted email timestamp is written into the information summary of the email.

In some embodiments, when extracting the information summary of each email, it is judged whether the email contains attachments, and if the email contains attachments, the binary variable indicating whether the attachment is included is set to 1 or the Boolean variable is set to True ; Otherwise, set the binary variable used to indicate whether there is an attachment to 0 or set the Boolean variable to False, and write the assigned variable to the message summary of the mail.

In some embodiments, when one or more pieces of information above are obtained and an information summary is generated, an information summary may be initialized, including four items: email type, email title, sender information, email timestamp, and whether it contains attachments. field, and write the information actually extracted from the current mail into the above 4 fields. Optionally, the information summary is in the form of a list, hash table, dynamic array, multiple sets of Key-Value data structures, URL (Uniform Resource Locator, unified resource locator) character string and other data forms, the embodiment of the present disclosure does not specifically limit the data form of the information summary.

In some embodiments, in addition to the above four fields, fields in the information summary can be flexibly added or deleted according to business requirements, for example, an email validity time field is added to indicate the validity time of the email (for example, before a certain time point valid), another example is to add an attachment valid time field to indicate the valid time of the attachment (for example, the attachment of virtual props must be received before a certain time point, otherwise it will be invalid), and the embodiment of the present disclosure does not specifically limit the field composition of the information summary .

In step 403, the service server generates a response carrying the information summary and the number of unread emails.

In some embodiments, the business server encapsulates the number of unread emails obtained in the above step 401 and the information summary generated in the above step 402 into the response, and then directly sends the response to the terminal that sends the mailing list pull request, which can reduce the Communication rounds save communication overhead.

In some embodiments, the business server sends the packaged response to the game server, and then the game server sends the above response to the terminal, which can ensure that the terminal is not aware of the background micro-service architecture, so that the dismantling of non-real-time services in the game The sub-deployment is transparent and imperceptible to the user side.

In the above steps 401-403, a possible implementation manner of generating the response by the business server is provided, that is, the business server side generates the response, and the business server directly returns the response to the terminal, or the business server sends the response to the game server and then the The game server forwards it to the terminal. Since the response only carries the information summary of each email that has not been pulled, and does not carry the email text of each email, the information summary itself already supports the normal display of the mailing list on the terminal side. , only when it is detected that the user checks a specific email, the email body of this email will be pulled, which not only greatly saves communication bandwidth and communication overhead, but also improves the efficiency of pulling requests from mailing lists. Response efficiency.

In some other embodiments, the business server notifies the email service API on the game server side of the number of unread emails obtained in the above step 401 and the information summary generated in the above step 402 in a callback manner, so that the game server can pass the mail service API , get the number of unread emails and information summary returned by the business server, then the game server encapsulates the number of unread emails and information summary into the response, and sends the response to the terminal, so that the business server does not need to parse the request or encapsulate the response, just It is only necessary to execute the corresponding database operation according to the business parameters and then return the completed business data (that is, the information summary and the number of unread emails), which greatly saves the processing resources of the business server.

In the above embodiments, it is provided how the service server side reads the emails not pulled from the terminal side from the email database and how to generate a response to the email list pulling request under different encoding methods of the email serial number on the business server side. In some embodiments, if the game server floods too many mailing list pull requests in the same time period, the business server may flood too many RPC requests in the same time period, which may cause the business server to be busy or go down. machine, in order to further ensure the high availability of the business server, the game server side can be divided into frames for a large number of mailing list pull requests that influx in the same time period, or, on the business server side, a large number of influx in the same time period The RPC request is divided into frames, that is, a timer is added to batch process a large number of mailing list pull requests or RPC requests that influx in the same period of time. Fig. 6 is a flow chart of a method for processing mailing list pull requests in frames according to an embodiment of the present disclosure. As shown in Fig. 6, a large number of RPC requests flooding in at the same time period are performed on the business server side in frames As an example for illustration, this method can be followed after step 304 in the above embodiment:

In step 601, when the cumulative number of multiple mailing list pull requests received within the same time period exceeds the request volume threshold, the business server caches multiple RPC requests associated with the multiple mailing list pull requests to the message in queue.

In some embodiments, the above-mentioned time period is taken as an example to describe the time period formed from the specified time before the current time to the current time, and the game server can count the cumulative number of mailing list pull requests received during the above-mentioned time period , and judge whether the number is greater than the request threshold. If the number is greater than the request threshold, it means that the framing operation needs to be enabled on the business server side, and the framing operation start instruction should be sent to the business server so that the business server will receive within the above time period. Received multiple RPC requests are cached in the message queue. The specified duration is a value greater than 0 pre-configured by the technician in the background, and the request volume threshold is an integer greater than 0 pre-configured by the technician in the background.

In some embodiments, there is no need for the game server to count the number of mailing list pull requests received within the above time period, but the business server counts the number of RPC requests received within the above time period by itself, and judges whether the number is greater than Request volume threshold, if the number is greater than the request volume threshold, it means that the business server needs to automatically enable the frame division operation, so that there is no need for the game server to give instructions, and it saves a round of communication overhead for the frame division operation activation command.

In some embodiments, when the business server side detects that the framing operation needs to be enabled, a message queue is created, and then multiple RPC requests received within the above time period are uniformly buffered into the message queue.

In step 602, the business server merges the RPC requests associated with the same mailing list pull request sent by the same originating account multiple times in the message queue, and configures a request times variable for the originating account.

In some embodiments, since the user is likely to send the same mailing list pull request multiple times in a short period of time, the service server needs to traverse the message queue once to process all the RPC requests from the same originating account in the message queue. Merge, that is, keep only one RPC request with the variable number of requests, and delete the remaining duplicate RPC requests, for example, keep only the RPC request with the earliest timestamp, delete the new RPC request later, and configure the reserved RPC request at the same time A request count variable, and assign the counted number of RPC requests from the originating account in the message queue to the above request count variable. It should be noted that, as time goes by, if it is still not the turn to process the RPC request , if a new repeated RPC request is subsequently received, the business server does not need to store the newly arrived repeated RPC request, but only needs to increment the variable of the number of requests above by 1, which can also save the storage cost of the business server.

In step 603, the service server reorders the RPC requests in the message queue based on the request times variable.

In some embodiments, after traversal of all RPC requests in the message queue in step 602, the message queue no longer contains repeated RPC requests from the same originating account. After that, the service server can variable to reorder the RPC requests in the message queue, which is equivalent to adding a variable of the number of requests as a weight to measure the urgency of the RPC request, because if the user side is more anxious to pull the mailing list, it is likely to The same mailing list pull request is triggered multiple times in a short period of time. Such requests need to be processed with priority, and such requests can be properly ranked at the front of the message queue.

Optionally, in the reordering process, the RPC requests in the message queue are sorted in descending order of the request times variable, such sorting logic is relatively simple and easy to implement, and the complexity is low.

Optionally, in the reordering process, for one or more RPC requests whose request times variable is greater than the target threshold, these RPC requests are placed in front of the rest of the RPC requests in the message queue, and are ordered from the oldest to the newest according to the request timestamp or Reorder according to the order of the number of requests variable from large to small. For the rest of the RPC requests whose request times variable in the message queue is less than or equal to the target threshold, they are still sorted according to the order of the original request timestamp from old to new. Among them, The target threshold is an integer greater than 0 pre-configured by the technician in the background.

Optionally, in the reordering process, each RPC request is weighted according to the two factors of the request timestamp and the number of requests to calculate a sorting weight, and then the message queue is sorted in order of the sorting weight from high to low Sort each RPC request in , which makes the sorting method more accurate, and can flexibly control the contribution ratio of the request timestamp and request times variables to the sorting weight, which has higher controllability.

In step 604, the service server processes at least one RPC request in the current batch in the reordered message queue in batches every target time interval.

In some embodiments, after reordering the individual RPC requests in the message queue based on the request times variable, a timer can be created, which is used to take out a batch of RPC requests at the top of the message queue from the message queue every interval target duration At least one RPC request of a batch, and perform serial or parallel processing on this batch of RPC requests based on the processing manners involved in the above embodiments. Among them, the target duration is a value greater than 0 pre-configured by the technician in the background, and the maximum RPC request capacity that can be processed in each batch is also a value greater than 0 pre-configured by the technician in the background. The target duration and batch are not correct here. The value of the capacity is specifically limited.

In an example, take the target duration of 1 second and the batch capacity of 100 as an example. A 1-second timer is configured on the business server side, and the top 100 RPC requests sorted are taken out from the message queue every 1 second for processing. , returns the corresponding response, and repeats the above operation until all RPC requests in the message queue are taken out.

In the above process, by providing a frame-based operation method for a large number of RPC requests pouring in at the same time period, it is possible to avoid excessive pressure on the business server due to a large number of players pulling the mailing list at the same time (it may even be overloaded and downtime), The usability of the business server is further improved.

(2) Email details pull business

Fig. 7 is a processing flowchart of an email details pull service provided by an embodiment of the present disclosure. The processing method is executed by a business server, and the business server may be an integrated server for processing various non-real-time businesses, or a separately deployed mail business server, wherein the business server is an exemplary description of computer equipment.

It should be noted that, here, only the game server sends the RPC request corresponding to the mail details pull request to the business server, and the processing flow after the business server creates a coroutine is described. For the implementation after step 305, please refer to the description of the foregoing embodiments for how the RPC request is sent from the game server to the service server, and how the service server creates a coroutine, and details are not repeated here.

In step 306-C1, the business server determines the email type and email sequence number requested by the email details pull request through the coroutine.

In some embodiments, when the terminal side detects the user's view operation on a specified email, it will initiate an email details pull request for the email, and the email details pull request carries the email type of the email and Mail sequence number. That is, the above-mentioned email type and email serial number will be encapsulated into the email details pull request as business parameters. After parsing the above-mentioned business parameters, the game server will inject the above-mentioned business parameters into the mail service API. Initiate an RPC request, and the RPC request carries the business parameters injected in the above-mentioned mail service API, so that after the business server creates a coroutine, the coroutine can obtain the above-mentioned mail type and mail serial number through the business parameters provided by the mail service API . Wherein, for the mail type and mail serial number, refer to the description of the previous embodiment, which will not be repeated here.

In step 306-C2, the service server initiates a read operation of the mail indicated by the mail serial number to the mail set indicated by the mail type in the database, and obtains the mail text and mail attachments of the mail.

Wherein, the read operation is used to read the mail body of the mail, and also read the attachment if the mail carries an attachment.

In some embodiments, in the case that personal emails and system emails are coded separately, if the email type is personal emails, then based on the account ID of the account, the personal email collection of the account is found in the email database, and the personal email collection is stored in the personal email collection. Query the mail hit by the mail serial number, then read the mail text of the mail, and read the mail attachment of the mail if the mail carries attachments; if the mail type is a system mail, then in the mail database system Query the mail that the mail serial number hits in the mail collection, then read the mail body of the mail, and also read the mail attachment of the mail when the mail carries an attachment.

In some embodiments, in the case of unified coding of personal mail and system mail, since the system mail will be stored in the personal mail collection when it is pulled by the terminal, the user can only edit the mail for which the information summary has been pulled. Initiate a view operation, indicating that the email indicated by the email details pull request must be the terminal that has loaded the information summary locally but has not loaded the email body (and email attachments). This type of email will be stored in the personal Therefore, regardless of whether the mail type is system mail or personal mail, it is directly based on the account ID of the account, finds the personal mail collection of the account in the mail database, and queries the mail hit by the serial number of the mail in the personal mail collection. , which then reads the message body of the message and, if the message has attachments, also reads the message's message attachments.

In step 306-C1 to step 306-C2, in the case that the non-real-time service is an email detail fetching service, a possible implementation manner of initiating the database operation of the non-real-time service through the coroutine is provided, that is, for After any email in the previous embodiment that only provides a summary of the information but does not provide the email body, when receiving the email details pull request for the email, you can go through steps 306-C1 to 306-C2 to extract the details from the email The email body (and email attachments) of the email is read in the database, so the performance overhead of a single email reading operation is very small, the response rate to the email detail pull request is high, and there is no need to pull the mailing list stage To provide the email body, the impact on the user side is almost imperceptible.

In step 701, the service server generates a response carrying the email body and the email attachment.

In some embodiments, the service server encapsulates the email body and email attachments obtained in the above step 306-C2 into a response, and then directly sends the response to the terminal that sends the pull request for email details, which can reduce communication rounds and save communication overhead.

In some embodiments, the business server sends the packaged response to the game server, and then the game server sends the above response to the terminal, which can ensure that the terminal is not aware of the background micro-service architecture, so that the dismantling of non-real-time services in the game The sub-deployment is transparent and imperceptible to the user side.

In the above step 701, a possible implementation manner of generating the response by the business server is provided, that is, the business server side generates the response, and the business server directly returns the response to the terminal, or the business server sends the response to the game server and then the game server forwarded to the terminal.

In some other embodiments, the business server notifies the mail text and mail attachments obtained in the above step 306-C2 to the mail service API on the game server side in a callback manner, so that the game server can obtain the reply from the business server through the mail service API. Then the game server encapsulates the email body and email attachments into the response and sends the response to the terminal. In this way, the business server does not need to parse the request or encapsulate the response. It only needs to perform the corresponding database operation according to the business parameters and return The business data (that is, the email body and email attachments) after the operation is sufficient, which greatly saves the processing resources of the business server.

It should be noted that the embodiment of the present disclosure only takes the case of an email carrying an attachment as an example. If the email does not carry an attachment, then in step 306-C2 only the text of the email is read without reading the attachment of the email, and in step 701 The generated response carrying the email body, that is, the email attachment is a default item, and the embodiment of the present disclosure does not specifically limit whether to carry the email attachment.

(3) Mail sending business

Fig. 8 is a processing flow chart of an email sending service provided by an embodiment of the present disclosure. As shown in Fig. 8, taking the game service request initiated by the account on the terminal side as an email sending request as an example, the processing method of the email sending request is determined by the service server For implementation, the service server may be an integrated server that processes various non-real-time services, or a separately deployed mail service server, wherein the service server is an exemplary description of computer equipment.

It should be noted that here only the game server sends the RPC request corresponding to the email sending request to the business server, and the processing flow after the business server creates the coroutine is described, that is, the solution of the embodiment of the present disclosure is the step in the preceding embodiment For the implementation after 305, please refer to the description of the foregoing embodiments for how the RPC request is sent from the game server to the service server, and how the service server creates a coroutine, and will not be repeated here.

In step 306-D1, the service server determines the mail type of the mail to be sent indicated by the mail sending request through the coroutine.

In some embodiments, the user can edit the email to be sent on the terminal side. When the terminal detects the sending operation of the email to be sent, it initiates an email sending request for the email to be sent, and the email sending request carries at least the email to be sent , optionally, the terminal can also generate the email type of the email to be sent based on the account authority of the terminal, and then encapsulate the email type into the email sending request, that is, the above email to be sent (or there is also an email type ) will be encapsulated into the email sending request as a business parameter. After the game server receives the email sending request, it analyzes the above business parameters. If the business parameters carry the email to be sent and the email type, inject the above business parameters into the mail service API, and the mail service API initiates an RPC request to the business server. The RPC request carries the business parameters injected in the above-mentioned mail service API, so that after the business server creates a coroutine, the coroutine can obtain the above-mentioned mail to be sent and the mail type through the business parameters provided by the mail service API; if the business parameters Only carry the email to be sent but not the email type. The game server can detect whether the sender is the game system or the game administrator. If so, set the email type to system email, and inject the email to be sent and the email type into the email service API, if not, set the mail type as personal mail, and inject the mail to be sent and the mail type into the mail service API. The subsequent process refers to the previous method and will not be repeated.

It should be noted that in different game business logics, email sending conditions can also be specified. For example, before the terminal sends an email to initiate a request, it needs to check whether the email body exceeds the set number of characters to avoid the content of the email body being too long. Whether the length of the list exceeds the set length to avoid too many emails for a single player, so I won’t repeat them here.

Through any of the above methods, the business server can directly obtain the mail to be sent and the mail type from the mail service API. If the mail type is personal mail, perform the following step 306-D2; if the mail type is system mail In the case of , execute the following step 306-D3.

In step 306-D2, when the email type is personal email, the service server initiates a write operation of the email to be sent to the personal email collection of the account in the database.

In some embodiments, when the mail type is personal mail, the business server finds the personal mail collection of the account in the mail database based on the account ID of the account, and creates a transaction of writing the mail to be sent in the personal mail collection, And use this transaction to initiate a write operation on the email to be sent.

In step 306-D3, when the email type is system email, the service server initiates a write operation of the email to be sent to the system email collection of the database.

In some embodiments, when the mail type is system mail, the service server finds the global system mail collection in the mail database, creates a transaction to write the mail to be sent in the system mail collection, and initiates The write operation for this pending message.

In step 306-D1 to step 306-D3, in the case that the non-real-time service is an email sending service, a possible implementation manner of initiating the database operation of the non-real-time service through the coroutine is provided, that is, for game users , through the above steps 306-D1 and 306-D2, the sending operation of personal mail can be realized; for the game administrator, the sending operation of system mail can be realized through the above step 306-D1 and step 306-D3, so that Provide a common interface for personal email or system email, or provide an interface for sending personal email and an interface for sending system email respectively, so as to achieve high availability of email sending services.

In step 801, the service server assigns a mail serial number to the mail to be sent based on the operation result of the writing operation.

In some embodiments, after the business server finishes writing the mail to be sent, if the operation result of the write operation indicates that the transaction is committed, it means that the mail to be sent has been successfully written into the corresponding mail collection and the data For sending, you can assign a unique and incremental mail serial number to the email to be sent. The encoding method of the mail serial number can be separate encoding for personal emails and system emails or unified encoding, so I won’t repeat them here; In the case of transaction rollback, directly generate and return a response to notify that the sending of the email failed.

In some embodiments, when the operation result of the write operation indicates that the transaction is committed, the service server detects the login status of the recipient account of the email to be sent after the serial number of the email is allocated. In the offline state of the game, execute step 802, and if the recipient account is in the online state of the game, execute step 803; optionally, if the email to be sent contains multiple recipient accounts, then detect the login status of each recipient account, Step 802 is executed for the recipient account in the game offline state, and step 803 is executed for the recipient account in the game online state.

In step 802, when the recipient account of the email to be sent is offline in the game, the service server generates a response notifying the sender account that the email is sent successfully.

In some embodiments, if the recipient's account is offline in the game, the service server can generate an ACK message as a response to the sender's account notification email being sent successfully. When the recipient's account is logged in to pull the mailing list for the first time, You will receive this pending email. Optionally, after the service server generates the above ACK message, the service server directly returns the above ACK message to the terminal, which can save communication overhead, or, the service server returns the above ACK message to the game server through the service API, so that the game server The above ACK message is sent to the terminal, which can reduce the perception of the terminal, ensure that the terminal has no perception of the service server, and the microservice framework is transparent to the user side.

In step 803, when the recipient account of the email to be sent is online in the game, the service server generates a response to notify the account that the email is sent successfully; and generates a response to push the email to the recipient account the response to.

In some embodiments, if the recipient account is in the game online state, then in addition to generating an ACK message as a response to the success of sending the sender account notification email in the same way as in step 802, it is also necessary to send an ACK message to the recipient account. New email alerts.

In some embodiments, the information digest of the email to be sent is extracted in the same way as step 402 in the previous embodiment, and the information abstract is encapsulated into a response to push the email to be sent to the recipient account (hereinafter referred to as the new email). Push response), and then, send the new email push response to the terminal directly or indirectly, and the sending method of the new email push response is the same as step 802, and will not be repeated.

In some other embodiments, the information abstract of the entire email to be sent is directly encapsulated together with the email body into the above-mentioned new email push response. In the embodiments of the present disclosure, only the information abstract is carried in the new email push response, or is the information abstract carried at the same time? and the body of the email are not specifically limited.

In the above steps 801 to 803, a possible implementation manner for the service server to generate a response is provided, that is, when the recipient account is offline on the service server side, it only generates an ACK message for the sender account to indicate that the email is sent successfully. When the sender’s account is online, in addition to generating an ACK message for the sender’s account to indicate that the email has been sent successfully, a new email push response is also generated for the recipient’s account. The above-mentioned various responses can be directly returned by the business server to the terminal, or by the business server The response is sent to the game server and forwarded by the game server to the terminal. By detecting the login status of the recipient account, when it is detected that the recipient account is in the online state of the game, a new email push response is returned to the recipient account, which can effectively prevent the recipient account from missing new emails and remind The recipient account can check new emails as soon as possible, which improves the efficiency and timeliness of email delivery.

In the above (1) to (3), the various mail services supported by the mail service system, such as mail list pull business, mail detail pull business, and mail sending business, are respectively introduced. It should be understood that the above types of business are only for mail As an example of business, the mail service system also supports other services such as marking read, deleting emails, and receiving attachments. The processing procedures of these services are similar and will not be enumerated one by one.

The following uses the scenario where the game administrator initiates a system email as an example to illustrate. Figure 9 is a processing flow of an email sending service provided by an embodiment of the disclosure. Email sending request; after the email sending request is parsed by the game server, a corresponding RPC request is generated and reaches the business server, and the main thread MailService of the business server applies to the mail database Mango for the mail serial number mailID of the next system mail; the mail database Mango sends The main thread MailService returns the mail serial number mailID; the main thread MailService fills the mail serial number mailID to the mail to be sent, and writes the mail to be sent filled with the mail serial number mailID into the system mail collection; the mail database Mango executes the The write operation returns the operation result after the write operation is completed; when the operation result indicates that the transaction is committed, the main thread MailService of the business server broadcasts to one or more logic processes of the game server Logic to notify that there is a new full-service system Mail; logic process Logic creates and maintains an object Avatar for each online player, and then notifies all online players of their respective object Avatars to realize full server broadcast of system mail.

In order to facilitate the understanding of the relationship between the logical process Logic and the object Avatar, please refer to Figure 5 above. One or more logical processes Logic can be created on the server side, and each logical process Logic will provide services to the object Avatar of one or more online players. , whenever an online player initiates a mail sending request, the mail sending request will be sent to the object Avatar on the logical process Logic, and then the object Avatar will parse the mail sending request and remotely call the mail on the remote business server Serving system 500.

In each of the above-mentioned embodiments, the processing flow of the mail service system at the back end of the server in various businesses is described in detail. Since the mail service system itself is of a large order of magnitude, and does not have high requirements for real-time performance (usually with messages in the game) nature, does not require real-time push or view), and the processing logic of the mail service system is relatively independent compared with the main business logic of the game. The split of the mail service system is realized through the micro-service architecture, and the mail service system is deployed in The remote business server allows the business server to support the mail function, which can greatly reduce the user load of the game server.

In the game scene, in addition to the mail service system, a type of message service system is also involved, which involves providing in-game IM message pull, send and add friends and other message services. The following describes the message service system for various message services. Discussion of processing flow categories.

(4) Unread message pulling business

Fig. 10 is a processing flowchart of an unread message pulling service provided by an embodiment of the present disclosure. As shown in Fig. 10 , taking the game service request initiated by the account on the terminal side as an unread message pulling request as an example, the unread message The processing method of the pull request is executed by a business server, which may be an integrated server for processing various non-real-time businesses, or a message business server deployed separately, wherein the business server is an example of computer equipment.

It should be noted that, here only the game server sends the RPC request corresponding to the unread message pull request to the business server, and the processing flow after the business server creates the coroutine is described, that is, the solution of the embodiment of the present disclosure is based on the aforementioned implementation For the realization after step 305 in the example, how to send the RPC request from the game server to the business server, and how the business server creates a coroutine, please refer to the description of the previous embodiment, and will not go into details.

In step 306-E1, the service server acquires the account to be queried carried in the pull request of unread messages and the maximum message identifier in the read messages of the session between the account and the account to be queried, ie the maximum message ID, through the coroutine.

Wherein, the maximum message ID indicates the latest read message in the session between the current account and the account to be queried.

In some embodiments, when the terminal side initiates an unread message pull request, it will determine the maximum message ID of each read message in the session between the current account and the account to be queried, for example, the above-mentioned maximum message ID is used as a service The parameters are encapsulated into the unread message pull request. After the game server parses the above business parameters, it injects the above business parameters into the message service API, and the message service API initiates an RPC request to the business server. The RPC request carries the above message service API The business parameters injected in , so that after the business server creates a coroutine, the coroutine can obtain the above-mentioned maximum message ID through the business parameters provided by the message service API. In other words, the service server can obtain the account number to be queried and the maximum message ID from the unread message pull request through the coroutine.

In step 306-E2, based on the maximum message ID, the business server initiates a batch read operation of unread messages to the message set of the account and the account to be queried in the database, and obtains multiple unread messages whose message ID is greater than the maximum message ID. information.

Wherein, the batch read operation is used to read multiple messages whose message IDs are greater than the maximum message ID.

In some embodiments, the database involved in the embodiments of the present disclosure refers to a message database, and the message database is used to store sent messages (such as chat records) in all sessions. For example, the message database can be a Redis storage cluster, and the Redis storage cluster It is a Key-Value database that supports high-concurrency services and has a list storage format, which is more suitable for message services that need to view historical messages.

Schematically, for the Redis message database, each message record in the conversation between each account and other accounts is stored in the Redis message database in the form of a message list, and each message record in the message list is implemented It is a dictionary. Different fields can be configured in the dictionary. For example, the following fields are configured in the dictionary: message sender, message content, sending time, etc.

Since message types can be divided into private sessions (referring to private chat sessions between two accounts) and group sessions (referring to group chat sessions between three or more accounts), in the Redis message database, private The message records of conversations and group conversations are stored in different channels. In the private conversation channel, the private conversation between each pair of accounts is stored as a private message list. The private message list is implemented with the Key-Value data structure, such as based on The account ID of each pair of accounts is used to construct the Key (key name) of the Key-Value data structure. In the group conversation channel, the group conversation of each group is stored as a group message list, and the group message list starts with Key-Value data structure implementation, such as building the Key of the Key-Value data structure based on the group ID, so that even if the members in the group change, there is no need to change the Key, which reduces the database performance overhead.

Schematically, for a private session between player A and player B, in the Redis message database, the Key-Value data structure Key is constructed based on player A's account ID-1 and player B's account ID-2, for example, first determine Find out the order of the account IDs of the two players in the ID dictionary, and build the following key according to the order of the account IDs in the ID dictionary from front to back: private_chat_between_1_2, the Key formed in this way can be used by player A or player B to query the session Messages are multiplexed, and there is no need to back up the respective session messages of the two players, which can reduce the database storage overhead.

In some embodiments, whether it is a private message list or a group message list in the Redis message database, whenever a new message is included, the service server will assign a self-incrementing message ID to the message. Since the message ID keeps increasing, In this way, the terminal side only needs to record the maximum message ID of the read message, and all messages with a message ID greater than the maximum recorded message ID in the message list are unread messages on the terminal side, which greatly simplifies the logic of pulling unread messages.

In some embodiments, when the service server acquires the account to be queried in the above step 306-E1, if the account to be queried is a personal account, it means that the request to pull is the unread message in the private session, if the account to be queried Is the group ID, which means that this request fetches unread messages in the group conversation.

In some embodiments, for the pull request of the unread message in the private session, the Key of the private session between the two accounts can be determined based on the current account and the account to be queried, and the determined Key can be used as an index in the Redis message database , query the corresponding Value, that is, the private message list of the private session, the messages in the private message list are arranged in order of message ID from small to large, and then, as indicated by the largest message ID obtained in the above step 306-E1 The next message of the latest read message starts to be read backwards in sequence until there is no new readable message, and all unread messages whose message ID is greater than the maximum message ID can be obtained.

In some embodiments, for a pull request of an unread message in a group session, the Key of the group session indicated by the group ID can be determined based on the group ID, and the determined Key can be used as an index in the Redis message database , the corresponding Value is queried, that is, the group message list of the group conversation. The messages in the group message list are arranged in order of message ID from small to large, and then, the largest message obtained from the above step 306-E1 The next message of the latest read message indicated by the ID starts to be read backwards in turn until there is no new readable message, and all unread messages whose message ID is greater than the maximum message ID can be obtained.

In the above step 306-E1 to step 306-E2, a possible implementation mode for the business server to initiate the database operation of the non-real-time business through the coroutine is provided, that is, whether it is for the unread message in the private session or the group session For a pull request, you only need to change the account to be queried recorded in the pull request, and encapsulate the largest message ID in the session into the pull request without other complicated processing. Under this message processing architecture, unread messages The amount of data carried by the pull request itself is very small, which greatly saves communication bandwidth and communication overhead.

Through the above steps 306-E1 to 306-E2, batch read operations to the Redis message database can be initiated. At this time, step 307 in the foregoing embodiment can still be executed, that is, when the operation result of the database operation is not obtained, the coordinator is blocked. Then, when the operation result of the database operation is obtained, if the operation result indicates transaction submission (rather than transaction rollback), the following steps 1001-1002 are performed:

In step 1001, the service server determines the number of unread messages based on the multiple messages returned by the operation result of the batch read operation.

In some embodiments, after the business server executes the batch read operation on unread messages, in the case that the operation result of the batch read operation indicates that the transaction is committed, it can obtain the batch read multiple messages (that is, all Unread messages), count the number of multiple messages read in batches above, and obtain the number of unread messages.

In step 1002, the service server generates a response carrying the multiple unread messages and the number of unread messages.

In some embodiments, the service server encapsulates the number of unread messages obtained in the above step 1001 and all the unread messages read in batches in the above step 306-E2 into the response, and then directly sends the response to the originating unread message The terminal for message pull requests can reduce communication rounds and save communication overhead.

In some embodiments, the business server sends the packaged response to the game server, and then the game server sends the above response to the terminal, which can ensure that the terminal is not aware of the background micro-service architecture, so that the dismantling of non-real-time services in the game The sub-deployment is transparent and imperceptible to the user side.

Fig. 11 is an interactive flowchart of an unread message pulling service provided by an embodiment of the present disclosure. As shown in Fig. 11 , the player triggers an unread message pulling request in the game application on the terminal side; the logic process on the game server side Logic maintains the player's object Avatar, receives the unread message pull request on the terminal side through the above object Avatar, and sends the RPC request associated with the unread message pull request to the main thread ChatService of the business server; then, the main thread ChatService Initiate a batch read operation of unread messages to the Redis message database; then, the Redis message database reads in batches all unread messages whose message IDs are greater than the maximum message ID of the read messages carried in the RPC request, and counts the read messages The number of unread messages of all unread messages, return all unread messages and the number of unread messages as business data to the main thread ChatService; the main thread ChatService can perform json.loads operations on business data, that is, all unread messages returned by the Redis message database The JSON string composed of read messages is converted into a Python dictionary by calling the json.loads() method, and the unread messages in the form of a Python dictionary and the number of the above unread messages are returned to the object Avatar on the logical process Logic; the object Avatar returns Python to the terminal A dictionary of unread messages and the number of unread messages mentioned above.

In the above steps 1001-1002, a possible implementation manner of generating the response by the business server is provided, that is, the business server side generates the response, and the business server directly returns the response to the terminal, or the business server sends the response to the game server and then the The game server forwards it to the terminal. Since the response carries not only all unread messages but also the number of unread messages, the number of unread messages can be rendered by the terminal side as "red dot data" in the message viewing interface. The red dot data Refers to: a type of UI display method in which the red dot represents the existence of unread messages and displays the number of unread messages. It can conveniently prompt whether there are unread messages and how many unread messages exist, which greatly improves the viewing of messages on the terminal side. The information volume and information density of the interface are conducive to improving the efficiency of users' information acquisition.

In other embodiments, the business server notifies the message service API on the game server side of the number of unread messages obtained in the above step 1001 and all the unread messages read in batches in the above step 306-E2 to the message service API on the game server side, so that The game server can obtain the number of unread messages and all unread messages returned by the business server through the message service API, and then the game server encapsulates the number of unread messages and all unread messages into the response, and sends the response to the terminal. The business server does not need to parse the request or encapsulate the response. It only needs to execute the corresponding database operation according to the business parameters and then return the completed business data (that is, all unread messages and the number of unread messages), which greatly saves the processing resources of the business server.

In the above embodiment, a possible implementation manner of pulling all unread messages and the number of unread messages (that is, red dot data) for any private session or group session is provided. Optionally, the terminal The terminal side can also initiate a separate red dot data pull request, that is, only pull the red dot data of each session, so that the red dot data of all sessions can be displayed normally on the message viewing interface on the terminal side, but all session data will not be loaded for now. Unread messages, only when the user's opening operation on a session is detected, the unread message pull request for the specified session will be triggered, which can save the communication overhead between the terminal and the server cluster, that is, when the message viewing interface is displayed It is not necessary to pull all unread messages of all sessions (this is likely to have a huge amount of data and occupy a lot of bandwidth), but only pulls the unread messages of the current session when a certain session is opened, which can also save terminal side storage overhead.

In the following, the terminal side pulls the red dot data through the red dot data pull request alone as an example for illustration.

Fig. 12 is an interactive flowchart of a red dot data pulling service provided by an embodiment of the present disclosure. As shown in Fig. 12, a player triggers a red dot data pull request in a game application on the terminal side; the logic process on the game server side Logic maintains the player's object Avatar, receives the red dot data pull request on the terminal side through the above object Avatar, and sends the RPC request associated with the red dot data pull request to the main thread ChatService of the business server; then, the main thread ChatService Initiate a query operation on the red dot data to the Redis message database; then, the Redis message database counts the number of unread messages whose message ID is greater than the maximum message ID of the read message carried in the RPC request, and returns the number of unread messages as red dot data The main thread ChatService; the main thread ChatService returns the red dot data to the object Avatar on the logic process Logic; the object Avatar returns the red dot data to the terminal.

Through the above method, for the accounts of both parties in the private session, only need to provide different maximum message IDs, on the basis of reusing the same private message list Key-Value data structure, the correct red dot data and Unread messages, that is, both parties in a private conversation can reuse the same chat record to find their designated chat messages, which greatly saves the storage overhead on the business server side.

In some embodiments, after obtaining the maximum message ID provided by each player, the business server caches the latest received maximum message ID in the Redis message database, and the maximum message ID will be replaced by the maximum message ID of the subsequent update. Coverage, so that the business server side can execute other business decisions based on the maximum message ID of the read message. For example, the business decision includes: when a new message is received, by comparing the message ID of the new message with the maximum message ID cached by the message receiver to determine whether to display or update unread messages and red dot data.

In some embodiments, for player A, when caching the maximum message ID of the private session between player A and player B, assuming that the maximum message ID of the message that player A has read in the above private session is 3, you can create The hash structure is as follows: Based on the account ID of player A, generate the key of the hash structure, namely private_chat_readflag_A, configure the Field of the hash structure as the account ID of player B, and configure the Value of the hash structure to 3, so that the business When the server side subsequently receives the updated maximum message ID, it only needs to modify the Value of the hash structure. Through the above Key-Field-Value three-level hash structure, the largest message ID of each player and all other players in the friend list in the private session can be stored concisely with a hash structure, which saves storage overhead on the one hand, On the other hand, this hash structure similar to the secondary index also greatly improves the indexing efficiency.

(5) Message sending service

Fig. 13 is a processing flow chart of a message sending service provided by an embodiment of the present disclosure. As shown in Fig. 13, taking the game service request initiated by the terminal side account as a message sending request as an example, the processing method of the message sending request is determined by the service server For execution, the service server can be an integrated server that processes various non-real-time services, or a message service server that is deployed separately, wherein the service server is an example of computer equipment.

It should be noted that here only the game server sends the RPC request corresponding to the message sending request to the business server, and the processing flow after the business server creates the coroutine is described, that is, the solution of the embodiment of the present disclosure is the step in the preceding embodiment For the implementation after 305, please refer to the description of the foregoing embodiments for how the RPC request is sent from the game server to the service server, and how the service server creates a coroutine, and will not be repeated here.

In step 306-F1, the service server determines the message type of the message to be sent indicated by the message sending request through the coroutine.

In some embodiments, the user can edit the message to be sent on the terminal side. When the terminal detects the sending operation of the message to be sent, it initiates a message sending request for the message to be sent, and the message sending request carries at least the message to be sent , optionally, the terminal can also determine the message type of the message to be sent by the message receiving account specified by the message to be sent, and then encapsulate the message type into the message sending request, that is, the above message to be sent (or also There is a message type) will be encapsulated into the message sending request as a business parameter. After receiving the message sending request, the game server parses to obtain the above business parameters. If the business parameters carry the message to be sent and the message type, the above business parameters are injected into the message service API, and the message service API initiates an RPC request to the business server. The RPC request carries the business parameters injected in the above-mentioned message service API, so that after the business server creates a coroutine, the coroutine can obtain the above-mentioned message to be sent and the message type through the business parameters provided by the message service API; if the business parameter Only carry the message to be sent but not the message type. The game server can detect whether the account receiving the message belongs to an account group. If so, set the message type to group message, and inject the message to be sent and the message type into the message service API, if not, set the message type as personal message, and inject the message to be sent together with the message type into the message service API. The subsequent process refers to the previous method and will not be repeated.

It should be noted that in different game business logics, message sending conditions can also be specified. For example, before the terminal sends a message to initiate a request, it needs to detect whether the message body exceeds the set number of characters to avoid the content of the message body being too long. Whether it contains sensitive words or not is used to verify the legitimacy of the message, so I won’t repeat it here.

Through any of the above methods, the service server can directly obtain the message to be sent and the message type from the message service API. In the case of a message, the following step 306-F3 is performed.

In step 306-F2, when the message type is a personal message, the service server initiates a write operation of the message to be sent to the message set of the account and message receiving account in the database.

In some embodiments, when the message type is a personal message, the service server determines the private session between the account and the message receiving account in the Redis message database based on the account ID of the account and the account ID of the message receiving account. Key, using the above-mentioned Key as an index to query the private message list of the above-mentioned private session in the Redis message database, this private message list is an exemplary description of the message collection in the Redis database. Next, create a transaction that inserts a new message to be sent into the private message list, and initiate a write operation of the message to be sent through this transaction, for example, insert the message to be sent into the Value( key value).

In step 306-F3, when the message type is a group message, the service server initiates a write operation of the message to be sent to the message set of the message receiving group in the database.

In some embodiments, when the message type is a group message, the message receiving account is actually provided as a message receiving group, and the service server determines the message receiving group ID in the Redis message database based on the group ID of the message receiving group. The Key of the group session of the message receiving group, the above-mentioned Key is used as an index to query the group message list of the above-mentioned group session in the Redis message database, and this group message list is a part of the message collection in the Redis database An exemplary description. Next, create a transaction that inserts a new message to be sent into the group message list, and use this transaction to initiate a write operation on the message to be sent, for example, insert the message to be sent into the Key-Value group message list Value.

In step 306-F1 to step 306-F3, in the case that the non-real-time service is a message sending service, a possible implementation manner of initiating the database operation of the non-real-time service through the coroutine is provided, that is, for a private session For the newly sent personal message, the operation of sending a personal message to the message receiving account can be realized through the above steps 306-F1 and 306-F2; for the newly sent group message in the group conversation, the above step 306-F1 can And step 306-F3, realize the operation of sending group messages in the message receiving group, so that a general interface for personal messages or group messages can be provided, or an interface for sending individual messages and sending of group messages can be provided respectively Interface to achieve high availability of message sending services.

In step 1301, the service server assigns a message ID to the message to be sent based on the operation result of the writing operation, and generates a response notifying the account that the message is sent successfully.

In some embodiments, after the business server finishes writing the message to be sent, if the operation result of the write operation indicates that the transaction is committed, it means that the message to be sent has been successfully written into the corresponding message set (private message list or group message list) and the data has been placed on the disk, the message to be sent can be assigned a unique message ID that keeps increasing. The encoding method of the message ID can be kept increasing in its own session or all messages on the server keep increasing, that is , keep the message ID incremental encoding for each session separately, or keep the incremental encoding for all messages in the whole server uniformly, and then generate a response (such as ACK message) to notify the account that the message is sent successfully, which will not be described again; in the write operation If the result of the operation indicates that the transaction is rolled back, it will directly generate and return a response that the sending of the notification message failed.

Optionally, after the service server generates the above ACK message, the service server directly returns the above ACK message to the terminal, which can save communication overhead, or, the service server returns the above ACK message to the game server through the service API, so that the game server The above ACK message is sent to the terminal, which can reduce the perception of the terminal, ensure that the terminal has no perception of the service server, and the microservice framework is transparent to the user side.

In some embodiments, when the operation result of the write operation indicates that the transaction is committed, the service server detects the login of the message receiving account of the personal message after allocating the message ID and in the case that the message to be sent is a personal message state, if the message receiving account is in the offline state of the game, return the ACK message generated above and exit the process, if the message receiving account is in the game online state, execute step 1302 to generate a new message push response to the message receiving account in the game online state; In the case that the message to be sent is a group message, since the message receiving group contains multiple member accounts, enter step 1303, that is, detect the login status of each member account in the message receiving group, and only for those who are in the online state of the game The online member account additionally generates a new message push response. Wherein, the new message push response is a response directed to an online message receiving account or an online member account in a message receiving group to notify that a new message has been received.

In step 1302, if the message to be sent is a personal message, the service server generates a response to push the message to be sent to the message receiving account only when the message receiving account of the personal message is in the game online state.

In some embodiments, when the message to be sent is a personal message, the service server detects the login status of the message receiving account of the personal message. If the message receiving account is offline in the game, the new message to be sent will be in the After the message receiving account logs in, the unread messages are fetched in batches for the first time, and real-time notification is not required; if the message receiving account is online in the game, a response to push the message to be sent to the message receiving account (hereinafter referred to as the new message) needs to be generated. Message Push Response) to notify the message receiving account that there is a new unread message, which is equivalent to realizing the real-time reminder mechanism after the new message is published.

In some embodiments, the above message to be sent is encapsulated into a new message push response, and the new message push response is sent to the terminal directly or indirectly. The sending method of the new message push response is the same as the sending of the ACK message in step 1301. The method is the same and will not be repeated here.

Hereinafter, it will be described by taking a new personal message sent by the player to the message receiving account as an example.

Fig. 14 is an interactive flow chart of a message sending service provided by an embodiment of the present disclosure. As shown in Fig. 14, a player triggers a message sending request for a personal message in a game application on the terminal side; Maintain the player's object Avatar, receive the message sending request on the terminal side through the above object Avatar, and send the RPC request associated with the message sending request to the main thread ChatService of the business server; then, the main thread ChatService detects that the message type is a personal message, The message content of the personal message can be pre-checked, such as sensitive word screening, etc., to ensure the legitimacy of the personal message; then, the main thread ChatService determines the two accounts according to the account ID of the player account and the account ID of the account receiving the message The Key of the private conversation between them, so as to query the private message list recorded in Value through the Key, and initiate a write operation of writing the personal message to the private message list to the Redis message database; the Redis message database returns the write to the main thread ChatService The operation result of the operation; then, in the case that the operation result indicates that the transaction is submitted, a new message ID that keeps increasing is assigned to the successfully written personal message, and the main thread ChatService instructs the Redis message database to directly link the player account to the The status of this personal message is marked as read (such as updating the maximum message ID cached by the player account to the newly assigned message ID for the personal message); then, the main thread ChatService detects the login status of the message receiving account, if the message receiving account is in In the online state, a new message push response is generated for the message receiving account, and the new message push response is pushed to other terminals logged into the message receiving account.

In step 1303, if the message to be sent is a group message, the service server pulls the latest member list of the message receiving group of the group message; The online member account pushes a response to the message to be sent.

In some embodiments, when the message to be sent is a group message, in order to avoid message push errors due to changes in member accounts in the message receiving group, the service server needs to pull the latest member list of the message receiving group , and traverse the login status of all member accounts in the latest member list, for each online member account in the online state of the game, generate a push response to the new message based on the same method as step 1302, and push the response to the new message in unicast , multicast or multicast to all terminals logged in by online member accounts; for each offline member account in the offline state of the game, this new message to be sent will be downloaded when the offline member account logs in for the first time to fetch unread messages in batches sent, no real-time notification is required, and no post-processing needs to be performed.

In some embodiments, the latest member list can be provided by another independent group service API and its business server deployed through the microservice architecture, or recorded locally on the business server of the message service system, or from the main server of the game server The source of the latest member list is not specifically limited here.

Hereinafter, it will be described by taking a new group message sent by a player in the message receiving group as an example.

Fig. 15 is an interactive flowchart of a message sending service provided by an embodiment of the present disclosure. As shown in Fig. 15 , the player triggers a message sending request for a group message in the game application on the terminal side; the logic process Logic on the game server side The player's object Avatar is maintained on the Internet, and the above-mentioned object Avatar receives the message sending request on the terminal side, and sends the RPC request associated with the message sending request to the main thread ChatService of the business server; then, the main thread ChatService detects that the message type is a group Message, request the latest member list of the message receiving group from the Redis message database; the Redis message database returns the latest member list of the message receiving group to the main thread ChatService; the main thread ChatService detects whether the latest member list is different from the local cached member list, If it is different, the latest member list is overwritten and cached locally, and then, the group message to be sent this time is written into the group message list of the message receiving group in the Redis message database, that is, the group message is sent The write operation of writing group message list; the Redis message database returns the operation result of the write operation to the main thread ChatService; when the operation result indicates that the transaction is committed, the main thread ChatService performs one by one based on the locally updated group member list. Detect the login status of the member account, generate a new message push response only for the online member account in the message receiving group, and push the new message push response to other terminals logged in by each online member account.

In the above steps 1301 to 1303, a possible implementation manner for the service server to generate a response is provided, that is, no matter for a personal message or a group message, the service server only responds to the online message receiving account or message receiving group The online member account of the online member additionally generates a new message push response. The above-mentioned ACK message or new message push response can be directly returned by the business server to the terminal, or the business server can send the response to the game server and then forwarded to the terminal by the game server. By detecting the login status of the message receiving account or the member accounts in the message receiving group, when it is detected that the message receiving account or the member accounts in the message receiving group are in the online state of the game, the message receiving account or the online member account are also checked Return a new message push response, which can effectively prevent the message receiving account or online member account from missing new messages, remind the message receiving account or online member account to check the new message as soon as possible, and improve the efficiency and timeliness of message delivery.

In the above (4) and (5), the various message services supported by the message service system, such as the unread message pull service, the red dot data pull service, and the message send service, are respectively introduced. It should be understood that the above-mentioned types of services are only As an example of the message service, the message service system also supports other services such as marking read and deleting messages. The processing procedures of these services are similar and will not be enumerated one by one.

(6) Account Adding Service

Fig. 16 is a flow chart of processing an account addition service provided by an embodiment of the present disclosure. As shown in Fig. 16, taking the game service request initiated by the account on the terminal side as an account addition request as an example, the processing method of the account addition request is determined by the service server For execution, the business server can be an integrated server that processes various non-real-time businesses, or a relational chain business server that is deployed separately, wherein the business server is an example of computer equipment.

It should be noted that, here only the game server sends the RPC request corresponding to the account addition request to the business server, and the processing flow after the business server creates the coroutine is described, that is, the solution of the embodiment of the present disclosure is the step For the implementation after 305, please refer to the description of the foregoing embodiments for how the RPC request is sent from the game server to the service server, and how the service server creates a coroutine, and will not be repeated here.

In step 306-G1, the business server performs authority verification on the account that initiates the account addition request and the target account that the account requests to add through the coroutine.

Wherein, the account addition request is used to apply for adding the target account to the account relationship chain of the account.

In some embodiments, the user can initiate an account addition request (such as applying to add friends) to the target account on the terminal side, and the account addition request carries at least the account ID of the initiator account and the account ID of the recipient account, that is, the target account. The above account ID of the initiator account and the account ID of the target account will be encapsulated into the account addition request as business parameters. After the game server receives the account addition request, it parses the above business parameters and injects the above business parameters into the message service API. The message service API initiates an RPC request to the business server. The RPC request carries the information injected into the above message service API. Business parameters, so that after the business server creates a coroutine, the coroutine can obtain the account ID of the initiator account and the account ID of the target account through the business parameters provided by the message service API.

In some embodiments, after the business server obtains the account ID of the initiator account and the account ID of the target account, it can perform a series of authority verifications on the initiator account and the target account, such as: detecting whether the number of friends of the initiator account has reached the number of friends List upper limit; detect whether the target account is in the blacklist of the initiator account; detect whether the initiator account's own application list exceeds the upper limit; detect whether the number of friends of the target account reaches the upper limit of the friend list; detect whether the initiator account is in the blacklist of the target account; Detect whether the friend request list of the target account exceeds the upper limit, etc. The detection logic of the above permission verification is flexibly configured by technicians according to the business requirements of game friends. The friends here refer to a pair of accounts that have a two-way or one-way relationship on the account relationship chain.

In the embodiment of the present disclosure, due to the adoption of coroutine development, if the detection logic of the above-mentioned permission verification is serial detection, then after starting a detection, the coroutine can be blocked and suspended, and after the detection result is returned, if the detection passes Then continue to start the next detection and then block and suspend the coroutine. If the detection fails, you can directly exit the detection logic, and return a response to the initiator account to notify the account of the failure to add. This coroutine development method, in the detection logic involved When the call chain is long, there is no need to define a large number of detection functions and callback functions. It only needs to trigger the overall detection logic once, and call back once after all the detection logic is executed, which is very beneficial to business expansion and maintenance.

After the business server has verified the permissions of both accounts through the detection logic, if the permission verification is passed, execute step 306-G2; if the permission verification fails, exit and return and return a response notifying the account addition failure to the initiator account. Optionally, the reason for the addition failure is also added in the response, that is, which test failed, so that the user can submit the account addition application again after solving related problems.

In step 306-G2, after the authority verification is passed, the business server initiates a database operation of writing the record added by the initiator account to the account of the target account to the database.

In some embodiments, the above-mentioned series of detection logics for authority verification are all passed, then the authority verification is deemed to be passed. Then, the business server side can maintain the account relationship chain of each account through the Mango relational database, and Supports the maintenance of dynamic changes to the account relationship chain. In addition to the Mango relationship database, it can also store the relationship chain data of the social network in the game in the form of a graph database, so I won’t repeat it here.

In some embodiments, the service server maintains a friend request list for each account in the Mango relational database, and the friend request list is used to record which accounts have initiated account addition requests to itself. Then, after the authority verification of the current account addition request is passed, the account ID of the target account is used as an index to query the friend application list of the target account, and create and write the initiator account into the friend application list (that is, send an account addition request. account) transaction, through which the database operation of adding records from the initiator account to the account of the target account is initiated. Enter operation.

In step 306-G1 to step 306-G2, in the case that the non-real-time service adds a service to an account, a possible implementation manner of initiating the database operation of the non-real-time service through the coroutine is provided, that is, through the Mango A friend request list is maintained for each account in the relational database, which simplifies the operation of adding account relationship chains to the write operation of writing the initiator account to the friend request list of the target account. If it involves the operation of adding friends in batches , you only need to write the originator account in the respective friend application lists of a series of accounts. The development complexity is low and easy to implement. This can provide a general interface for adding friends individually or in batches, or provide a separate interface for individual The interface for adding friends and the interface for adding friends in batches to achieve high availability of the account adding business.

In step 1601, when the operation result indicates that the account addition record has been written, the service server generates an account addition notification response to the target account.

In some embodiments, after the service server completes the write operation of writing the initiator account to the friend application list of the target account, if the operation result of the write operation indicates that the transaction is submitted, the representative has written the initiator account The friend application list of the target account has completed the writing operation of the account addition record and the data has been placed on the disk, and can generate a response (such as an ACK message) to notify the initiator account that the application is successfully sent, which will not be described again; after writing If the operation result of the operation indicates that the transaction is rolled back, it will directly generate and return a response notifying that the application has failed to send.

Optionally, after the service server generates the above ACK message, the service server directly returns the above ACK message to the terminal, which can save communication overhead, or, the service server returns the above ACK message to the game server through the service API, so that the game server The above ACK message is sent to the terminal, which can reduce the perception of the terminal, ensure that the terminal has no perception of the service server, and the microservice framework is transparent to the user side.

In some embodiments, the service server can detect the login status of the target account, and when the target account is in the offline state of the game, the new account addition request can be viewed when the target account logs in and pulls the friend application list for the first time. Perform post-processing; when the target account is in the online state of the game, an account addition notification response can be generated for the target account, and the account addition notification response can be directly or indirectly pushed to other terminals logged in by the target account. Wherein, the account addition notification response is a response to the online target account notifying that a new account addition application has been received, and the sending method of the account adding notification response is the same as the sending method of the above-mentioned ACK message, and will not be repeated here.

Hereinafter, it will be described by taking that player A initiates an account addition request to player B as an example.

Fig. 17 is an interactive flowchart of an account addition service provided by an embodiment of the present disclosure. As shown in Fig. 17, player A triggers an account addition request for the target account held by player B in the game application on the terminal side; The main thread FriendService on the server side receives the RPC request associated with the account addition request through the game server, and starts the pre-check (that is, authorization verification) for the accounts of both parties, such as whether the upper limit of the number of friends of both parties is exceeded, whether the upper limit of the number of applications is reached, whether the Included in the other party’s blacklist, etc.; after the verification is passed, the main thread FriendService initiates a write operation to the Mango relational database to write the friend application list of the target account into the player A’s account; the Mango relational database executes the above write operation, and writes to the main thread FriendService returns the operation result of the write operation; then, when the operation result indicates that the transaction is submitted, on the one hand, it prompts player A to log in to the terminal that the account addition request has been successfully sent; on the other hand, it detects the login status of the target account, If the target account is in an online state, an account addition notification response is generated for the target account, and the account addition notification response is sent to other terminals logged in by the target account.

In the above step 1601, a possible implementation manner for the service server to generate a response is provided, that is, after the initiator account is written into the friend application list of the target account, the service server returns an ACK message to the initiator account, and the above ACK The message can be directly returned by the service server to the terminal, or the service server can send the response to the game server and then forwarded to the terminal by the game server. Further, by detecting the login status of the target account, when it is detected that the target account is in the online state of the game, the target account is also returned with an account addition notification response, which can effectively prevent the target account from missing the above account addition application and remind the target account as soon as possible Review and process the above account addition application, which improves the delivery efficiency and timeliness of business requests.

It can be seen that in the mail service system, message service system, and relationship chain service system, it often involves mass sending of emails for a certain account group, or sending group messages within a certain account group, or sending messages to a certain account group. Group accounts initiate account addition requests in batches, which involves group business, but since the members in the group are not static, it may involve the exit of old members or the joining of new members. Therefore, the main logic process of the game server can dynamically Maintain the list of group members, and other services interact with the main logic process when necessary, or, different service servers dynamically maintain the list of group members, and periodically synchronize the list of group members. In the embodiment of the present disclosure, It also involves another way to dynamically maintain the list of group members, that is, separate a group service API and deploy a business server for providing group services in a microservice architecture, which can be a single group Group business servers, or CDN server clusters with a distributed architecture, are no longer limited.

For the group service system (GroupService), it can be dedicated to maintaining the latest member lists of various temporary or non-temporary account groups, such as account groups include: game alliances, game guilds, temporary teams, dungeon teams, etc., group The group service API is used to support a series of business requirements such as account group creation, dissolution, member joining, and member exit. For account groups, the login status of member accounts (game online or game offline) will not affect the membership relationship within the account group. Therefore, a group service API and its supporting business server are separately deployed to maintain each The latest member list of an account group, which can facilitate others such as mail business or message business to call the group service API, and then pull the latest member list of the specified group, without the need for mail business server or message business server to calculate. Or maintain the latest member list. Since the maintenance of the latest member list is migrated to the external group service system, it can speed up the response rate of cross-services such as group chat message pull, group chat red dot data pull, group email, and batch addition of friends. . Schematically, the group relationship database in the group service system is a Redis storage cluster, which records the latest member list of each account group in the form of Key-Value data structure, for example, the group ID of the account group is used as the Key , using the latest member list of the account group as the Value to maintain the group membership.

Fig. 18 is a business flow chart of a group service system provided by an embodiment of the present disclosure. As shown in Fig. 18, when group members change (such as old members quitting, new members joining, etc.), the terminal side will The group change request for group member change sends its RPC request to the main thread GroupService of the business server through the game server; the main thread GroupService obtains the change operation of the group member of the target group based on the RPC request, and instructs Redis The group relational database executes the corresponding change operation on the latest member list of the target group; the Redis group relational database returns the operation result of the change operation to the main thread GroupService, so that the latest member list can be dynamically maintained.

In each of the above-mentioned embodiments, the processing flow of the mail service system, the message service system and the group service system on the backend of the server are introduced in detail. Since these service systems do not have high requirements for real-time performance, and the processing logic Compared with the main business logic of the game, which is relatively independent, the split of the above types of service systems is realized through the micro-service architecture, and the split service systems are deployed on remote business servers, so that the business servers can support their respective Business functions can greatly reduce the user load of the game server, and when a certain type of business is upgraded or iterated, the code logic of the business server where it is located can be independently modified without affecting the game's main business logic or other irrelevant businesses The normal operation of logic simplifies the difficulty of game back-end development and improves the scalability of game applications. Moreover, since it avoids the development mode of integrating all businesses in the overall architecture of the game server, it also effectively avoids the problem of cascading faults, prevents the unavailability of a single business module from blocking all business progress, and because it is split and deployed The various service systems of the game have a certain degree of independence, so they can be easily migrated to other game products, and have extremely high portability.

Fig. 19 is a logical structural block diagram of an apparatus for processing a game service request according to an embodiment of the present disclosure. Referring to FIG. 19 , the device includes a determining unit 1901 , a querying unit 1902 and a sending unit 1903 .

The determining unit 1901 is configured to execute a game service request in response to an account, and determine a service type of the game service request, where the service type indicates the timeliness attribute of the game service associated with the game service request;

The determining unit 1901 is further configured to determine a service interface matching the non-real-time service when the service type indicates that the game service is a non-real-time service;

The query unit 1902 is configured to query the address of the service server for providing the service interface from the service registration center, and the service registration center is used to record the addresses of the service servers of various interfaces;

The sending unit 1903 is configured to send a remote procedure call (RPC) request to the address based on the service interface, where the RPC request is used to instruct the service server to provide the account with a response to the game service.

The device provided by the embodiment of the present disclosure, through the game service request requesting non-real-time service, because the real-time requirements are not high, there is no need for the game server to perform real-time processing locally, so the service registration center can be found to be dedicated to processing the non-real-time service. service API, and then make RPC remote call to the remote business server through the service API, so that the user load related to non-real-time business can be migrated from the game server to the business server, and the resource configuration of the game server is optimized. The iteration and update of non-real-time business only needs to modify the code logic in the business server, and modify the service API if necessary, which does not involve patching the main business logic of the game, which reduces the development complexity and improves the game development efficiency. The non-real-time business can be deployed separately in different business servers, so that when some business functions are blocked, it will not affect the normal use of other business functions, and will not affect the main business logic of the game, which greatly improves the usability of the game .

In some embodiments, the query unit 1902 is configured to perform:

From the service registry, query the set of addresses used to provide the service interface;

From the address set, query the address of the business server with the closest geographic distance to the account.

In some embodiments, based on the composition of the device in Figure 19, the device further includes:

A creating unit configured to execute a coroutine for creating the non-real-time service in response to the RPC request through the service server;

an initiating unit configured to execute the database operation of initiating the non-real-time service through the coroutine;

The blocking unit is configured to block and suspend the coroutine before obtaining the operation result of the database operation;

The returning unit is configured to, after obtaining the operation result of the database operation, return a response generated based on the operation result.

In some embodiments, the game service request is a mailing list pull request; the initiating unit is configured to perform:

Through this coroutine, obtain the maximum personal email sequence number and the maximum system email sequence number in the pulled emails of the account from the mailing list pull request;

Based on the maximum personal email serial number, initiate a batch read operation of personal emails to the personal email collection of the account in the database. The batch read operation is used to read multiple personal emails whose email serial numbers are greater than the maximum personal email serial number mail;

Based on the maximum system mail serial number, a batch read operation of system mail is initiated to the system mail collection of the database, and the batch read operation is used to read multiple system mails whose mail serial numbers are greater than the maximum system mail serial number.

In some embodiments, the game service request is a mailing list pull request; the initiating unit is configured to perform:

Use this coroutine to obtain the maximum email sequence number in the pulled emails of the account carried in the mailing list pull request;

Based on the maximum mail sequence number, a batch read operation of system mail is initiated to the system mail collection of the database, and the batch read operation is used to read multiple system mails whose mail sequence numbers are greater than the maximum mail sequence number;

storing the plurality of system emails in the personal email collection of the account in the database;

Based on the maximum mail sequence number, a batch read operation of mails is initiated to the personal mail collection, and the batch read operation is used to read a plurality of mails whose mail sequence numbers are greater than the maximum mail sequence number.

In some embodiments, based on the composition of the apparatus in FIG. 19 , the apparatus further includes a generation unit configured to execute:

Determine the number of unread emails based on the multiple emails returned by the operation result of the batch read operation;

Extracting information summaries of the plurality of emails, where the information summaries are used to provide at least one of the following: email type, email title, sender information, email timestamp and whether it contains attachments;

A response is generated with a digest of the message and an unread count for the message.

In some embodiments, based on the apparatus composition of FIG. 19 , the apparatus further includes a batch processing unit configured to perform:

When the number of multiple mailing list pull requests received in the same time period exceeds the request volume threshold, the service server caches multiple RPC requests associated with the multiple mailing list pull requests into the message queue;

In the message queue, merge the RPC requests associated with the same mailing list pull request sent multiple times by the same initiating account, and configure the request times variable for the initiating account;

Reordering each RPC request in the message queue based on the request times variable;

At least one RPC request in the current batch in the reordered message queue is processed in batches at each target time interval.

In some embodiments, the game service request is a pull request for email details; the initiating unit is configured to perform:

Determine the email type and email serial number requested by the email details pull request through this coroutine;

Initiate a read operation of the mail indicated by the serial number of the mail to the collection of mail indicated by the mail type in the database. The read operation is used to read the mail body of the mail, and if the mail carries attachments, Also read the attachment.

In some embodiments, the game service request is an email sending request; the initiating unit is configured to perform:

Determine the mail type of the mail to be sent indicated by the mail sending request through the coroutine;

In the case that the email type is a personal email, initiate a write operation to the email to be sent to the personal email collection of the account in the database;

In the case that the mail type is a system mail, a write operation of the mail to be sent is initiated to the system mail collection of the database.

In some embodiments, based on the composition of the apparatus in FIG. 19 , the apparatus further includes a generation unit configured to execute:

Based on the operation result of the write operation, assign a mail serial number to the mail to be sent;

When the recipient account of the email to be sent is offline in the game, generate a response to notify the account that the email is sent successfully;

When the recipient account of the email to be sent is in the game online state, generate a response to notify the account that the email is successfully sent; and generate a response to push the email to the recipient account.

In some embodiments, the game service request is an unread message pull request; the initiating unit is configured to perform:

Through the coroutine, the account to be queried and the maximum message ID are obtained from the unread message pull request, and the maximum message ID indicates the latest read message in the session between the account and the account to be queried;

Based on the maximum message identifier, initiate a batch read operation of unread messages to the message set of the account and the account to be queried in the database, and the batch read operation is used to read multiple messages whose message identifier is greater than the maximum message identifier .

In some embodiments, based on the composition of the apparatus in FIG. 19 , the apparatus further includes a generating unit configured to execute:

Determine the number of unread messages based on the multiple messages returned by the operation result of the batch read operation;

A response carrying the plurality of unread messages and the number of unread messages is generated.

In some embodiments, the game service request is a message sending request; the initiating unit is configured to perform:

Determine the message type of the message to be sent indicated by the message sending request through the coroutine;

In the case that the message type is a personal message, initiate a write operation of the message to be sent to the message set of the account and the message receiving account in the database;

In the case that the message type is a group message, a write operation of the message to be sent is initiated to the message collection of the message receiving group in the database.

In some embodiments, based on the composition of the apparatus in FIG. 19 , the apparatus further includes a generating unit configured to execute:

Based on the operation result of the write operation, assign a message identifier to the message to be sent, and generate a response to notify the account that the message is successfully sent;

For the personal message, only when the message receiving account is in the online state of the game, generate a response to push the message to be sent to the message receiving account;

For the group message, the latest member list of the message receiving group is pulled; only for the online member account in the latest member list, a response of pushing the message to be sent to the online member account is generated.

In some embodiments, the game service request is an account addition request, and the account addition request is used to apply for adding the target account to the account relationship chain of the account; the initiating unit is configured to execute:

Through this coroutine, verify the authority of the account;

After the verification is passed, initiate a database operation to write the record added by the account to the account of the target account to the database;

Based on the device composition of Figure 19, the device also includes a generating unit configured to perform:

When the operation result indicates that the account addition record has been written, an account addition notification response to the target account is generated.

With regard to the apparatus in the above embodiments, the specific manner in which each unit executes operations has been described in detail in the embodiment of the game service request processing method, and will not be described in detail here.

FIG. 20 is a schematic structural diagram of a computer device provided by an embodiment of the present disclosure. The computer device 2000 may have relatively large differences due to different configurations or performances, and may include one or more than one processor (Central Processing Units, CPU) 2001 and One or more memories 2002, wherein at least one piece of program code is stored in the memory 2002, and the at least one piece of program code is loaded and executed by the processor 2001 to implement the game service request processing method provided by the above-mentioned embodiments. Of course, the computer device 2000 may also have components such as wired or wireless network interfaces, keyboards, and input and output interfaces for input and output. The computer device 2000 may also include other components for implementing device functions, which will not be described in detail here.

In an exemplary embodiment, there is also provided a computer-readable storage medium including at least one instruction, such as a memory including at least one instruction, and the at least one instruction can be executed by a processor in a computer device to complete the above-mentioned embodiment. The processing method of the game service request. Optionally, the above-mentioned computer-readable storage medium may be a non-transitory computer-readable storage medium, for example, the non-transitory computer-readable storage medium may include ROM (Read-Only Memory, Read Only Memory), RAM (Random-Access Memory , random access memory), CD-ROM (CompactDisc Read-Only Memory, CD-ROM), magnetic tape, floppy disk and optical data storage devices, etc.

In an exemplary embodiment, a computer program product is also provided, including one or more instructions, which can be executed by a processor of a computer device, so as to complete the game service request provided by each of the above embodiments. Approach.

Other embodiments of the present disclosure will be readily apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. The present disclosure is intended to cover any modification, use or adaptation of the present disclosure. These modifications, uses or adaptations follow the general principles of the present disclosure and include common knowledge or conventional technical means in the technical field not disclosed in the present disclosure. . The specification and examples are to be considered exemplary only, with a true scope and spirit of the disclosure being indicated by the following claims.

It should be understood that the present disclosure is not limited to the precise constructions which have been described above and shown in the drawings, and various modifications and changes may be made without departing from the scope thereof. The scope of the present disclosure is limited only by the appended claims.

Claims (18)

1. A method for processing game service request is characterized by comprising the following steps:

responding to a game service request of an account, and determining a service type of the game service request, wherein the service type indicates the timeliness attribute of the game service associated with the game service request;

determining a service interface matched with the non-real-time service under the condition that the service type indicates that the game service is the non-real-time service;

inquiring addresses of service servers for providing the service interfaces from a service registration center, wherein the service registration center is used for recording the addresses of the service servers of various interfaces;

based on the service interface, sending a Remote Procedure Call (RPC) request to the address, wherein the RPC request is used for indicating the service server to provide a response to the game service for the account.

2. The method for processing game service request according to claim 1, wherein said querying an address of a service server for providing the service interface from a service registry comprises:

querying, from the service registry, a set of addresses for providing the service interface;

and inquiring the address of the service server closest to the account in geographic distance from the address set.

3. The method for processing game service request according to claim 1, wherein the method further comprises:

responding to the RPC request through the service server, and creating a coroutine of the non-real-time service;

initiating database operation of the non-real-time service through the coroutine;

before an operation result of the database operation is obtained, blocking and suspending the coroutine;

and after an operation result of the database operation is acquired, returning a response generated based on the operation result.

4. The method of claim 3, wherein the game service request is a mailing list pull request; the initiating the database operation of the non-real-time service through the coroutine comprises:

through the coroutine, the maximum personal mail serial number and the maximum system mail serial number in the pulled mails of the account are obtained from the mail list pulling request;

initiating a batch reading operation of the personal mails to a personal mail set of the account in a database based on the maximum personal mail serial number, wherein the batch reading operation is used for reading a plurality of personal mails with mail serial numbers larger than the maximum personal mail serial number;

and initiating a batch reading operation of the system mails to a system mail set of a database based on the maximum system mail serial number, wherein the batch reading operation is used for reading a plurality of system mails of which the mail serial numbers are greater than the maximum system mail serial number.

5. The method of claim 3, wherein the game service request is a mailing list pull request; the initiating the database operation of the non-real-time service through the coroutine comprises:

acquiring the maximum mail serial number in the pulled mail of the account number carried in the mail list pulling request through the coroutine;

based on the maximum mail serial number, initiating batch reading operation on the system mails to a system mail set of a database, wherein the batch reading operation is used for reading multiple system mails with mail serial numbers larger than the maximum mail serial number;

storing the multiple system mails into a personal mail set of the account in the database;

and initiating batch reading operation on the mails to the personal mail set based on the maximum mail serial number, wherein the batch reading operation is used for reading multiple mails of which the mail serial numbers are greater than the maximum mail serial number.

6. The method for processing game service request according to claim 4 or 5, wherein the method further comprises:

determining the unread number of mails based on the multiple mails returned by the operation result of the batch reading operation;

extracting the message abstract of the multi-piece mail, wherein the message abstract is used for providing at least one of the following items: mail type, mail title, sender information, mail timestamp and whether an attachment is contained;

and generating a response carrying the information abstract and the unread mail number.

7. The method for processing game service request according to claim 4 or 5, wherein the method further comprises:

under the condition that the quantity of a plurality of accumulated received mail list pulling requests exceeds a request quantity threshold value in the same time period, caching a plurality of RPC (remote procedure call) requests related to the plurality of mail list pulling requests into a message queue through the service server;

in the message queue, combining RPC requests associated with the same mail list pull requests sent by the same initiating account for multiple times, and configuring a request time variable for the initiating account;

reordering each RPC request in the message queue based on the request time variable;

and at least one RPC request in the current batch in the reordered message queue is processed in batches at intervals of the target duration.

8. The method for processing a game service request according to claim 3, wherein the game service request is a mail detail pull request; the initiating the database operation of the non-real-time service through the coroutine comprises:

determining the mail type and the mail serial number requested to be pulled by the mail detail pulling request through the coroutine;

and initiating a reading operation of the mail indicated by the mail serial number to a mail set indicated by the mail type in a database, wherein the reading operation is used for reading a mail body of the mail and reading the attachment under the condition that the mail carries the attachment.

9. The method for processing game service request according to claim 3, wherein the game service request is a mail sending request; the initiating the database operation of the non-real-time service through the coroutine comprises:

determining the mail type of the mail to be sent indicated by the mail sending request through the coroutine;

initiating a writing operation on the mail to be sent to a personal mail set of the account in a database under the condition that the mail type is a personal mail;

and under the condition that the mail type is a system mail, initiating a writing operation on the mail to be sent to a system mail set of a database.

10. The method for processing game service request according to claim 9, wherein the method further comprises:

distributing a mail serial number for the mail to be sent based on the operation result of the writing operation;

under the condition that the account of the receiver of the mail to be sent is in the off-line state of the game, generating a response for informing the account that the mail is sent successfully;

under the condition that the account of the receiver of the mail to be sent is in a game online state, generating a response for informing the account that the mail is sent successfully; and generating a response for pushing the mail to be sent to the account of the receiver.

11. The method of claim 3, wherein the game service request is an unread message pull request; the initiating the database operation of the non-real-time service through the coroutine comprises:

acquiring an account to be queried and a maximum message identifier from the unread message pull request through the protocol, wherein the maximum message identifier indicates the latest read message in the session between the account and the account to be queried;

and initiating batch reading operation of unread messages to the account and the message set of the account to be inquired in the database based on the maximum message identifier, wherein the batch reading operation is used for reading a plurality of messages of which the message identifiers are larger than the maximum message identifier.

12. The method for processing game service request according to claim 11, wherein the method further comprises:

determining the quantity of unread messages based on a plurality of messages returned by the operation result of the batch reading operation;

and generating a response carrying the plurality of unread messages and the number of the unread messages.

13. The method for processing game service request according to claim 3, wherein the game service request is a message transmission request; the initiating the database operation of the non-real-time service through the coroutine comprises:

determining the message type of the message to be sent indicated by the message sending request through the coroutine;

initiating a writing operation on the message to be sent to a message set of the account and a message receiving account in a database under the condition that the message type is the personal message;

and under the condition that the message type is a group message, initiating a writing operation on the message to be sent to a message set of a message receiving group in a database.

14. The method for processing game service request according to claim 13, wherein the method further comprises:

distributing a message identifier for the message to be sent based on the operation result of the write operation, and generating a response for successfully sending the account notification message;

for the personal message, only under the condition that the message receiving account is in a game online state, generating a response for pushing the message to be sent to the message receiving account;

for the group message, pulling the latest member list of the message receiving group; and generating a response for pushing the message to be sent to the online member account only for the online member account in the latest member list.

15. The method for processing the game service request according to claim 3, wherein the game service request is an account adding request, and the account adding request is used for applying for adding a target account to an account relation chain of the account; the initiating the database operation of the non-real-time service through the coroutine comprises:

performing authority verification on the account number through the coroutine;

after the verification is passed, initiating database operation of writing in a record added to the account of the target account by the account to a database;

after the operation result of the database operation is obtained, returning a response generated based on the operation result comprises:

and generating an account addition notification response to the target account under the condition that the operation result indicates that the writing of the account addition record is completed.

16. A device for processing game service requests, comprising:

the determining unit is configured to execute a game service request responding to an account number, and determine a service type of the game service request, wherein the service type indicates the aging attribute of a game service associated with the game service request;

the determining unit is further configured to determine a service interface matched with the non-real-time service under the condition that the service type indicates that the game service is the non-real-time service;

the query unit is configured to execute query of addresses of the service servers for providing the service interfaces from a service registry, wherein the service registry is used for recording the addresses of the service servers of various interfaces;

a sending unit configured to execute sending a Remote Procedure Call (RPC) request to the address based on the service interface, wherein the RPC request is used for instructing the service server to provide a response to the game service to the account.

17. A computer device, comprising:

one or more processors;

one or more memories for storing the one or more processor-executable instructions;

wherein the one or more processors are configured to execute the instructions to implement the method of processing a game service request of any one of claim 1 to claim 15.

18. A computer-readable storage medium, wherein at least one instruction of the computer-readable storage medium, when executed by one or more processors of a computer device, enables the computer device to perform a method of processing a game service request as recited in any one of claims 1-15.

Images