CN114443181A

CN114443181A - Service processing method, application generation method, server, device and equipment

Info

Publication number: CN114443181A
Application number: CN202210111794.3A
Authority: CN
Inventors: 韩伟
Original assignee: Beijing Zitiao Network Technology Co Ltd
Current assignee: Beijing Zitiao Network Technology Co Ltd
Priority date: 2022-01-29
Filing date: 2022-01-29
Publication date: 2022-05-06

Abstract

The utility model provides a service processing method, an application generation method, a server, a device, equipment and a storage medium, when generating an application, the class of a target object can be set to be associated with the base class of an object library, and a lock mechanism aiming at the object service is added in the base class. Therefore, a locking mechanism is applied to the service, the data consistency of the object in the service processing process can be ensured, the data processing capacity and the resource occupancy rate are effectively reduced, the running performance and the service processing efficiency of the application are improved, and in addition, only one locking mechanism needs to be added in the base class during programming application, so that the code quantity can be effectively reduced, the light weight of the application code is realized, the coding workload of developers is effectively reduced, and the consumption of manpower and material resources is greatly reduced.

Description

Service processing method, application generation method, server, device and equipment

Technical Field

The present disclosure relates to the field of computer applications, and in particular, to a service processing method, an application generating method, a server, an apparatus, a device, and a storage medium.

Background

In recent years, games have been increasingly favored. In the actual game operation, the situation that a plurality of client processes need to modify the same data often occurs, so that the results of modifying the data for a plurality of times are mutually overlapped, and at the moment, the problem of data consistency can be faced.

At present, for the situation that a plurality of processes need to modify the same data, two methods, namely a pessimistic lock for queuing a plurality of modification operations and an optimistic lock for adding a version number to each modification operation, are generally used. The existing pessimistic locking and optimistic locking methods lock data to be modified of each object, and the operation has high requirements on programming, large workload of developers, large application files, large occupied memory during operation, high resource consumption and low service processing efficiency.

Disclosure of Invention

The embodiment of the disclosure at least provides a service processing method, an application generation method, a server, a device, equipment and a storage medium.

The embodiment of the disclosure provides a service processing method, which comprises the following steps:

responding to a trigger operation of a user for a target object, and receiving a service request which is sent by a client and initiated for the target object, wherein the service request comprises an object address of the target object in a target process;

determining the target object running in the target process based on the object address, wherein the target object is generated based on a class which is written in advance and comprises business logic, the class inherits a base class of a preset object library, and a lock mechanism aiming at a plurality of object businesses is added in the base class;

and controlling the target object to realize the target service corresponding to the service request according to a locking mechanism corresponding to the service request, wherein the class comprises the target service, and the target service is registered in advance as being capable of being called externally and is bound with the corresponding locking mechanism.

In an optional implementation manner, before the receiving, in response to a trigger operation of a user for a target object, a service request initiated for the target object and sent by a client, the method includes:

determining the object address of the target object in the target process based on the target process in which the target object is located;

and sending the object address to a client so that the client initiates a service request aiming at the target object based on the object address.

In an optional embodiment, when the application is running, the target object is generated based on the following steps:

when an application is started, determining a target process for running a target object in a distributed server cluster, initializing the target process, and generating the target object in the target process based on a class which is written in advance and comprises business logic; or

And in the running process of the application, responding to an event request sent by a client, and generating a target object in a target process based on a class which is written in advance and comprises business logic.

In an optional implementation manner, in a case that a lock mechanism corresponding to the service request is a pessimistic lock, controlling the target object to implement a target service corresponding to the service request according to the lock mechanism corresponding to the service request includes:

determining a target service corresponding to the service request;

adding the target service to a corresponding message queue, wherein the message queue is used for storing the object service of each user aiming at the target object, and the service content of the object service is the same as that of the target service;

and controlling the target object to realize the target service when the target service is rotated according to the arrangement sequence of the services in the message queue.

In an optional implementation manner, in a case that a lock mechanism corresponding to the service request is an optimistic lock, controlling a target object to implement a target service corresponding to the service request according to the lock mechanism corresponding to the service request includes:

determining a target service corresponding to the service request;

adding a version number to the target service;

and controlling the target object to realize the target service based on the version number.

In an optional implementation manner, after the controlling, according to the lock mechanism corresponding to the service request, the target object to implement the target service corresponding to the service request, the method includes:

determining a service result of the target object for completing the target service;

and sending the service result to the client so that the client presents the content corresponding to the service result.

The embodiment of the present disclosure further provides an application generation method, where the method includes:

acquiring a class of a target object written by a user, application logic of an application to be generated and a preset object library, wherein the class comprises service logic of the target object;

associating the class with a base class of the object library to control the class to inherit the base class at runtime;

adding a locking mechanism aiming at a plurality of object services in the base class;

registering object services capable of being called externally in the base class;

and generating the application file of the application to be generated based on the processed object library, the class and the application logic.

An embodiment of the present disclosure further provides a server, where the server includes:

the service receiving module is used for responding to the triggering operation of a user for a target object, receiving a service request which is sent by a client and is initiated for the target object, wherein the service request comprises an object address of the target object in a target process;

an object determining module, configured to determine the target object running in the target process based on the object address, where the target object is generated based on a pre-written class including service logic, the class inherits a base class of a preset object library, and a lock mechanism for multiple object services is added in the base class;

and the service execution module is used for controlling the target object to realize the target service corresponding to the service request according to the locking mechanism corresponding to the service request, wherein the class comprises the target service, and the target service is registered in advance to be capable of being called externally and is bound with the corresponding locking mechanism.

In an optional implementation manner, the server further includes an address sending module, and the address sending module is configured to:

In an optional implementation manner, the service receiving module generates the target object based on the following steps:

In an optional implementation manner, when the lock mechanism corresponding to the service request is a pessimistic lock, the service execution module controls the target object to implement the target service corresponding to the service request according to the lock mechanism corresponding to the service request, and is specifically configured to:

determining a target service corresponding to the service request;

and controlling the target object to realize the target service when the target service is reached according to the arrangement sequence of the services in the message queue.

In an optional implementation manner, when the lock mechanism corresponding to the service request is an optimistic lock, the service execution module controls the target object to implement the target service corresponding to the service request according to the lock mechanism corresponding to the service request, and is specifically configured to:

determining a target service corresponding to the service request;

adding a version number to the target service;

In an optional implementation manner, the server further includes a result sending module, where the result sending module is configured to:

An embodiment of the present disclosure further provides an application generating apparatus, where the apparatus includes:

the information acquisition module is used for acquiring classes of a target object written by a user, application logic of an application to be generated and a preset object library, wherein the classes comprise service logic of the target object;

the base class association module is used for associating the class with a base class of the object library so as to control the class to inherit the base class during running;

a lock mechanism adding module, configured to add a lock mechanism for a plurality of object services in the base class;

a service registration module, configured to register, in the base class, an object service that can be called externally among the multiple object services;

and the file generation module is used for generating the application file of the application to be generated based on the processed object library, the class and the application logic.

An embodiment of the present disclosure further provides an electronic device, including: the system comprises a processor, a memory and a bus, wherein the memory stores machine readable instructions executable by the processor, the processor and the memory are communicated through the bus when the electronic device runs, and the machine readable instructions are executed by the processor to execute the business processing method and the application generation method or the steps in any possible implementation mode of the business processing method and the application generation method.

The embodiments of the present disclosure also provide a computer-readable storage medium, where a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the computer program executes the steps in any possible implementation manner of the service processing method and the application generation method, or the service processing method and the application generation method.

According to the service processing method, the application generating method, the server, the device, the equipment and the storage medium provided by the embodiment of the disclosure, when an application is generated, a class of a target object can be set to be associated with a base class of an object library, a lock mechanism for an object service is added in the base class, the class of the target object can inherit the base class of the object library during application running, and when a service request initiated for the target object is received, the target object can be controlled to realize the target service corresponding to the service request according to the lock mechanism added in the base class. Therefore, a locking mechanism is applied to the service, the data consistency of the object in the service processing process can be ensured, the data processing capacity and the resource occupancy rate are effectively reduced, the running performance and the service processing efficiency of the application are improved, and in addition, only one locking mechanism needs to be added in the base class during programming application, so that the code quantity can be effectively reduced, the light weight of the application code is realized, the coding workload of developers is effectively reduced, and the consumption of manpower and material resources is greatly reduced.

In order to make the aforementioned objects, features and advantages of the present disclosure more comprehensible, preferred embodiments accompanied with figures are described in detail below.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present disclosure, the drawings required for use in the embodiments will be briefly described below, and the drawings herein incorporated in and forming a part of the specification illustrate embodiments consistent with the present disclosure and, together with the description, serve to explain the technical solutions of the present disclosure. It is appreciated that the following drawings depict only certain embodiments of the disclosure and are therefore not to be considered limiting of its scope, for those skilled in the art will be able to derive additional related drawings therefrom without the benefit of the inventive faculty.

Fig. 1 is a schematic view illustrating an application scenario of a service processing method according to an embodiment of the present disclosure;

FIG. 2 is a flow chart illustrating a method for generating an application provided by an embodiment of the present disclosure;

FIG. 3 illustrates a schematic diagram of application generation provided by an embodiment of the present disclosure;

FIG. 4 is a schematic diagram illustrating data interaction during application running according to an embodiment of the present disclosure;

fig. 5 is a flowchart illustrating a service processing method provided by an embodiment of the present disclosure;

FIG. 6 is a schematic diagram illustrating a method for determining a target object according to an embodiment of the disclosure;

FIG. 7 is a schematic diagram illustrating a target service implemented according to an optimistic lock according to an embodiment of the present disclosure;

fig. 8 is a flowchart illustrating another service processing method provided by the embodiment of the present disclosure;

FIG. 9 shows one of the schematic diagrams of a server provided by the disclosed embodiments;

fig. 10 illustrates a second schematic diagram of a server provided by the embodiment of the present disclosure;

fig. 11 is a schematic diagram illustrating an application generation apparatus provided in an embodiment of the present disclosure;

fig. 12 shows a schematic diagram of an electronic device provided by an embodiment of the present disclosure.

Detailed Description

In order to make the objects, technical solutions and advantages of the embodiments of the present disclosure more clear, the technical solutions of the embodiments of the present disclosure will be described clearly and completely with reference to the drawings in the embodiments of the present disclosure, and it is obvious that the described embodiments are only a part of the embodiments of the present disclosure, not all of the embodiments. The components of the embodiments of the present disclosure, generally described and illustrated in the figures herein, can be arranged and designed in a wide variety of different configurations. Thus, the following detailed description of the embodiments of the present disclosure, presented in the figures, is not intended to limit the scope of the claimed disclosure, but is merely representative of selected embodiments of the disclosure. All other embodiments, which can be derived by a person skilled in the art from the embodiments of the disclosure without making creative efforts, shall fall within the protection scope of the disclosure.

It should be noted that: like reference numbers and letters refer to like items in the following figures, and thus, once an item is defined in one figure, it need not be further defined and explained in subsequent figures.

The term "and/or" herein merely describes an associative relationship, meaning that three relationships may exist, e.g., a and/or B, may mean: a exists alone, A and B exist simultaneously, and B exists alone. In addition, the term "at least one" herein means any one of a plurality or any combination of at least two of a plurality, for example, including at least one of A, B, C, and may mean including any one or more elements selected from the group consisting of A, B and C.

Research has found that, at present, for improving data consistency, two types of methods, namely a pessimistic lock for queuing multiple modification operations and an optimistic lock for adding a version number to each modification operation, are generally used. The existing pessimistic locking and optimistic locking methods lock data to be modified of each object, and the operation has high requirements on programming, large workload of developers, large application files, large occupied memory during operation, high resource consumption and low service processing efficiency.

Based on the research, the present disclosure provides a service processing method and an application generating method, where when an application is generated, a class of a target object may be set to be associated with a base class of an object library, and a lock mechanism for an object service is added to the base class, and when the application runs, the class of the target object may be inherited to the base class of the object library, and when a service request initiated for the target object is received, the target object may be controlled to implement the target service corresponding to the service request according to the lock mechanism added to the base class. Therefore, a locking mechanism is applied to the service, the data consistency of the object in the service processing process can be ensured, the data processing capacity and the resource occupancy rate are effectively reduced, the running performance and the service processing efficiency of the application are improved, and in addition, only one locking mechanism needs to be added in the base class during programming application, so that the code quantity can be effectively reduced, the light weight of the application code is realized, the coding workload of developers is effectively reduced, and the consumption of manpower and material resources is greatly reduced.

To facilitate understanding of the present embodiment, first, a business processing method disclosed in the embodiments of the present disclosure is described in detail, where an execution subject of the business processing method provided in the embodiments of the present disclosure is generally an electronic device with certain computing capability, and the electronic device includes, for example: terminal equipment or servers or other processing devices. In some possible implementations, the business process method may be implemented by a processor calling computer readable instructions stored in a memory.

Referring to fig. 1, fig. 1 is a schematic view of an application scenario of a service processing method according to an embodiment of the present disclosure. As shown in fig. 1, in a practical application scenario, a server is included, and a plurality of clients that can be connected to the server in a communication manner are included, and the clients and the server can perform data exchange. In practical application, an application file is configured in the server, a plurality of clients can initiate service requests to the same service object in the server, and the server can implement tasks corresponding to the service requests based on a mechanism corresponding to the service requests.

For example, the server may be a game server, and the terminal may be a game player terminal, and during the game, a plurality of players may make the same series of business logic requests for the same object. For example, in a game in which one game background is pet care, a plurality of players can feed the same cat, and in this case, the server needs to respond to service requests of terminals corresponding to the plurality of players and implement a target service corresponding to the service request.

Referring to fig. 2, fig. 2 is a flowchart of an application generation method according to an embodiment of the disclosure. As shown in fig. 2, the application generation method provided by the embodiment of the present disclosure includes:

s201: the method comprises the steps of obtaining a class of a target object written by a user, application logic of an application to be generated and a preset object library, wherein the class comprises business logic of the target object.

In this step, a developer writes a class including a service logic of a target object to be generated in advance, and also sets an object library and an application logic of an application to be generated in advance, so that the class, the application logic, and the object library can be directly acquired.

The application to be generated, which is the user of the application logic, may set a plurality of object services in the object library based on the object library.

The object library is a set of containers of distributed objects, which are used by developers when writing applications, provides a base class, and can generate various types of target objects customized by users based on the object library, and the target objects can automatically obtain the capability of solving the problem of data consistency through the function of the object library, and in addition, the address of the target object and the address of a process sending a service request to the target object can be recorded in the object library.

S202: and performing association processing on the class and a base class of the object library so as to control the class to inherit the base class at runtime.

In this step, the object library is provided with a base class, and in order to enable the class to inherit the base class of the object library, the class needs to be associated with the base class.

The base class is a type facing the application to be generated and including the commonality of all entities.

S203: and adding a locking mechanism aiming at a plurality of object businesses in the base class.

In this step, a lock mechanism for a plurality of object services may be added in the base class, so that, when a subsequent application runs, the target object may be controlled to implement the target service corresponding to the service request according to the lock mechanism corresponding to the service request.

S204: and registering the object service capable of being called externally in the base class.

In this step, in an actual situation, one target object corresponds to a plurality of object services, some object services need to be called and presented by the client, and some object services do not need to be called and presented by the client, so that the plurality of object services set in the object library include object services that can be called externally and object services that cannot be called externally, and only the object services that can be called externally need to be registered in the base class.

It is to be understood that the locking mechanisms added in the base class for the plurality of object services include locking mechanisms corresponding to the object services.

For example, in a game in which the game context is feeding a pet, only the business of the subject that exhibits pet satiety associated with feeding is required, and no business of the subject that exhibits pet cleanliness values is required, so only the business of the subject that exhibits pet satiety needs to be registered in the base class, and no business of the subject that exhibits pet cleanliness values needs to be registered in the base class.

S205: and generating the application file of the application to be generated based on the processed object library, the class and the application logic.

In this step, the processed object library, the class and the application logic are determined, and the processed object library, the class and the application logic are integrated through the processing of a compiler and a linker to form the application file of the application to be generated.

Referring to fig. 3, fig. 3 is a schematic diagram of application generation. As shown in fig. 3, after the class is determined, an application function processing module is obtained through the action of the compiler, after the application logic is determined, an application server assembly module is obtained through the action of the compiler, and in the case that the application function processing module, the application server assembly module and the object library are determined, an application executable file is obtained through integration by a linker.

The application generation method provided by the embodiment of the disclosure can obtain a class of a target object written by a user, an application logic of an application to be generated and a preset object library, where the class includes a service logic of the target object, associate the class with a base class of the object library to control the class to inherit the base class during running, add a lock mechanism for a plurality of object services in the base class, register an object service capable of being called externally in the plurality of object services in the base class, and generate an application file of the application to be generated based on the processed object library, the class and the application logic.

Therefore, when writing applications, only one-time locking mechanism needs to be added in the base class, the number of codes can be effectively reduced, the lightweight of the application codes is realized, the coding workload of developers is effectively reduced, and the consumption of manpower and material resources is greatly reduced.

Referring to fig. 4, fig. 4 is a schematic diagram of data interaction in an application running process according to an embodiment of the present disclosure. As shown in fig. 4, in the process of running an application, first, a client initiates a request for creating an object, a server responds to the request sent by the client to create a target object and simultaneously generates an object address of the target object in a target process, then, the server returns the object address to the client, the client can initiate a service request for the target object only under the condition of obtaining the object address, and then, when receiving a service request initiated by the client and initiated for the target object, the server can understand that the service request includes the object address of the target object in the target process, so as to process a target service corresponding to the service request, obtain a service result, and return the service result to the client.

Referring to fig. 5, fig. 5 is a flowchart of a service processing method according to an embodiment of the disclosure. As shown in fig. 5, the service processing method provided by the embodiment of the present disclosure includes:

s501: responding to a trigger operation of a user for a target object, and receiving a service request which is sent by a client and initiated for the target object, wherein the service request comprises an object address of the target object in a target process.

In this step, when receiving a trigger operation of a user for a target object, in response to the trigger operation of the user for the target object, it can be understood that the trigger operation is accompanied by a service request, and therefore, the service request initiated for the target object and sent by a client may be received.

For example, in a game in which the game background is feeding a pet, the user triggers a button for feeding the pet, i.e. the user triggers feeding, and accordingly, the client sends a business request for increasing the satiety value of the fed pet.

And the target object is generated in a target process based on a class which is written in advance and comprises business logic when the application runs.

Illustratively, in a game in which the game background is pet care, a pre-written class is obtained, and after instantiation of the class, a target object whose object is a cat is generated in a target process.

Specifically, in an optional implementation, the target object is generated based on the following steps:

In this step, the time for generating the target in the target process based on the class including the service logic written in advance may be a time for determining the target process for running the target object in the distributed server cluster and initializing the target process when the application is started, or a time for responding to an event request sent by the client in the running process of the application.

For example, in a game with a game background of caring for pets, the target object of the cat may be generated when the game is started, or may be generated after a player initiates a cat feeding event during the running of the game.

The generated target object is stored in a target process in a multi-process cluster with self-adjusting load balancing and availability, so that the memory occupation ratio can be reduced, and the capacity of the existing data cache system is higher than that of a common data cache system.

The cluster specifically includes several processes, each process specifically includes several objects, and the objects are set according to an actual game mechanism, which is not limited herein.

It is understood that the service request includes an object address of the target object in the target process, so that the target object can be found from the distributed server cluster based on the object address when the service request is received. Further, only when the object address is obtained, the client may locate the target object, and then initiate a service request for the target object, for which reason, the object address needs to be sent to the client in advance, so that the client initiates the service request.

Accordingly, in an optional implementation manner, before the receiving, in response to the user's trigger operation for the target object, a service request initiated for the target object and sent by a client, the method includes:

In this step, in a case of generating the target object, the target object may be located, so as to determine a target process in which the target object is located, and further, an object address of the target object in the target process may be determined, so as to send the object address to a client, so that the client initiates a service request for the target object based on the object address.

The client is a caller who needs to initiate a call to the target object. In addition, the client may be a portable mobile smart device such as a smart phone, a tablet computer, and a wearable device, and may also be a personal computer terminal, which is not limited herein.

Illustratively, in the case where a player feeds a cat, the target address where the cat is located is sent to the client of the player who feeds the cat.

S502: and determining the target object running in the target process based on the object address, wherein the target object is generated based on a class which is written in advance and comprises business logic, the class inherits a base class of a preset object library, and a locking mechanism aiming at a plurality of object businesses is added in the base class.

In this step, in the case of determining the object address, the target process may be determined according to the object address, so as to determine the target object running in the target process.

Illustratively, taking fig. 6 as an example, fig. 6 is a schematic diagram of determining a target object, as shown in fig. 6, in a distributed server cluster, including a process 1, a process 2, a process 3, and a process 4, each process has a different object created therein, and each object has an object address in the process. When a service request initiated by a client is received, taking address 4 included in the service request as an example, according to an object address of a target object included in the service request in a target process, it may be determined that the target object is cat 4 running in process 3.

The class includes business logic and also includes a mechanism capable of remote calling. Because the class inherits the base class of the preset object library in the application, and the lock mechanism aiming at the plurality of object services is added in the base class, the method aiming at the plurality of object services included in the class is correspondingly bound with the lock mechanism.

The lock mechanism is a mechanism for coordinating a plurality of processes or threads to concurrently access a certain resource. In a database, besides the contention of traditional computer resources, data is also a resource which needs to be shared by users, and the establishment of a locking mechanism can solve the consistency and effectiveness of concurrent access of the data.

The locking mechanism includes, but is not limited to, pessimistic locks, optimistic locks, exclusive locks, shared locks, public locks, non-public locks, and spin locks.

The implementation of the pessimistic lock mechanism is to mark a lock on the same object called by multiple processes or threads, when a process or thread wants to make a service request on the object, the lock needs to be obtained first, and if other processes or threads are using the lock of the object at the moment, the lock needs to wait, so as to implement the queue-waiting execution of multiple service requests.

The optimistic lock mechanism is realized by additionally adding a version number to each read and write operation of an object, wherein the version number represents the number of times that data corresponding to the object is modified, so that before each write operation, whether the data is modified by other processes or threads can be distinguished, and only under the condition that the version number of the write operation is consistent with that of the read operation, the service request is regarded as successful processing, so that a correct service processing result is obtained.

S503: and controlling the target object to realize the target service corresponding to the service request according to a locking mechanism corresponding to the service request, wherein the class comprises the target service, and the target service is registered in advance as being capable of being called externally and is bound with the corresponding locking mechanism.

In this step, under the condition that the target object is determined, based on the target service included in the class, the target service is registered as being capable of being called externally when the class is written in advance, and a corresponding lock mechanism is bound, the lock mechanism corresponding to the service request may be determined, and the target object is controlled to implement the target service corresponding to the service request according to the lock mechanism corresponding to the service request.

And the target service is a service of a binding locking mechanism in the object service.

The target service is bound with a corresponding lock mechanism, which may be a definition that adds a corresponding lock attribute to the target service, so that the target service can be processed according to the lock mechanism in the processing process.

The locking mechanism includes, but is not limited to, a pessimistic locking mechanism and an optimistic locking mechanism.

For example, in the case that multiple players feed the same cat, when receiving a service request for feeding initiated based on the address of the cat and sent by multiple clients of multiple players, the feeding of the same cat by the multiple players is implemented according to a lock mechanism corresponding to the service request for feeding.

Therefore, in an optional implementation manner, in a case that the lock mechanism corresponding to the service request is a pessimistic lock, controlling the target object to implement the target service corresponding to the service request according to the lock mechanism corresponding to the service request includes:

determining a target service corresponding to the service request;

In this step, when the lock mechanism corresponding to the service request is a pessimistic lock, a target service corresponding to the service request is determined, then according to the pessimistic lock mechanism, a message queue for storing the object service of the target object by each user is set, the service content of the object service is the same as that of the target service, the target service is added to the corresponding message queue, the services in the message queue are arranged and executed according to the sequence, when the target service is not reached, the target service is queued in the message queue to be executed, and when the target service is reached, the target object is controlled to realize the target service.

Illustratively, player a, player b, and player c feed the same cat, and three feeding services are added to the message queue and are sequentially queued for execution, and for the service of feeding cat by player c, the service of feeding cat by player c is first waited when the service of feeding cat by player a is executed, then the service of feeding cat by player c is waited when the service of feeding cat by player b is executed, and finally, the task is executed until the service of feeding cat by player c is executed.

Furthermore, in an optional implementation manner, in a case that the lock mechanism corresponding to the service request is an optimistic lock, controlling the target object to implement the target service corresponding to the service request according to the lock mechanism corresponding to the service request includes:

determining a target service corresponding to the service request;

adding a version number to the target service;

In this step, when the lock mechanism corresponding to the service request is an optimistic lock, a target service corresponding to the service request is determined first, then a version number is added to the target service according to the optimistic lock mechanism, and when the version number is added, the target object can be controlled to implement the target service based on the version number.

Illustratively, taking fig. 7 as an example, fig. 7 is a schematic diagram of implementing a target service according to optimistic lock, as shown in fig. 7, player a and player b feed the same cat, player a feeds cat with 10 o ' clock cat food, player b feeds cat with 20 o ' clock cat food, add version number "1" to the process C where the cat is located, process a where player a feeds cat food obtains the current satiety value data 100 o ' clock of the process C, and at the same time, process a also obtains the current version number "1" of the process C, after player a finishes feeding cat food with 10 o ' clock cat food, process a sends back the data that the cat satiety value needs to be increased by 10 o ' clock after player a feeds cat food to process C, and sends back the version number "1" obtained by process a, because the version number sent back by process a is the same as the current version number of process C, and is also "1", this processing operation is correct, the process C accepts the operation of the process a, the cat-full value data in the process C is increased by 10 points, becomes 110 points, and the version number of the process C is changed to "2".

Further, if the process B where the cat is fed by the player B and the process a simultaneously obtain the cat satiety value data 100 points in the process C, the process B also obtains the version number "1" of the process C, after the player B finishes feeding the cat 20 points, the process B sends back the data that the cat satiety value needs to be increased by 20 points after the player B feeds the cat, the data is sent back to the process C, the version number "1" obtained by the process B is sent back, because the version number of the process C is changed to be "2" at the moment and the two version numbers are different, the process C rejects the operation of the process B, the process C sends an error prompt to the process B, the process B receives the error prompt, re-obtains the cat satiety value data 110 points in the process C, and simultaneously obtains the current version number "2" of the process C, after the player B finishes feeding the cat 20 points, the process B sends back the data that the cat satiety value needs to be increased by 20 points after the player B feeds the cat to the process C, and the version number "2" obtained by the process B is sent back at the same time, because the version number sent back by the process B is the same as the current version number of the process C and is also "2", the processing operation is correct, the process C receives the operation of the process B, the cat satiety value data in the process C is increased by 20 points and changed into 130 points, and the version number of the process C is changed into "3".

The service processing method provided by the embodiment of the disclosure receives a service request initiated for a target object and sent by a client in response to a trigger operation of a user for the target object, wherein the service request includes an object address of the target object in a target process; determining the target object running in the target process based on the object address, wherein the target object is generated based on a class which is written in advance and comprises business logic, the class inherits a base class of a preset object library, and a lock mechanism aiming at a plurality of object businesses is added in the base class; and controlling the target object to realize the target service corresponding to the service request according to a locking mechanism corresponding to the service request, wherein the class comprises the target service, and the target service is registered in advance as being capable of being called externally and is bound with the corresponding locking mechanism.

Therefore, the data consistency of the objects in the service processing process can be ensured by applying a locking mechanism aiming at the service, the data processing amount is effectively reduced, the service processing efficiency is improved, the resource occupancy rate is further reduced, and the running performance of the application is improved.

Referring to fig. 8, fig. 8 is a flowchart of another service processing method according to an embodiment of the present disclosure. As shown in fig. 8, the service processing method provided by the embodiment of the present disclosure includes:

s801: responding to a trigger operation of a user for a target object, and receiving a service request which is sent by a client and initiated for the target object, wherein the service request comprises an object address of the target object in a target process.

S802: and determining the target object running in the target process based on the object address, wherein the target object is generated based on a class which is written in advance and comprises business logic, the class inherits a base class of a preset object library, and a locking mechanism aiming at a plurality of object businesses is added in the base class.

S803: and controlling the target object to realize the target service corresponding to the service request according to a locking mechanism corresponding to the service request, wherein the class comprises the target service, and the target service is registered in advance as being capable of being called by the outside and is bound with a corresponding locking mechanism.

The descriptions of step S801 to step S803 may refer to the descriptions of step S501 to step S503, and the same technical effect and the same technical problem can be achieved, which are not described herein again.

S804: and determining a service result of the target object for completing the target service.

In this step, under the condition that the target object is controlled to implement the target service corresponding to the service request, a service result that the target object completes the target service can be obtained.

S805: and sending the service result to the client so that the client presents the content corresponding to the service result.

In this step, in a case that the service result is determined, the service result may be sent to the client, and the client may present corresponding content based on the service result.

Illustratively, in the case where a player feeds a cat with 10 points of cat food, the satiety value of the cat is presented at the player's client interface as 10 points of increase.

The service processing method provided by the embodiment of the present disclosure receives, in response to a trigger operation of a user for a target object, a service request initiated for the target object and sent by a client, where the service request includes an object address of the target object in a target process; determining the target object running in the target process based on the object address, wherein the target object is generated based on a class which is written in advance and comprises business logic, the class inherits a base class of a preset object library, and a lock mechanism aiming at a plurality of object businesses is added in the base class; and controlling the target object to realize the target service corresponding to the service request according to a locking mechanism corresponding to the service request, wherein the class comprises the target service, and the target service is registered in advance as being capable of being called externally and is bound with the corresponding locking mechanism.

It will be understood by those skilled in the art that in the method of the present invention, the order of writing the steps does not imply a strict order of execution and any limitations on the implementation, and the specific order of execution of the steps should be determined by their function and possible inherent logic.

Based on the same inventive concept, a server corresponding to the service processing method is also provided in the embodiments of the present disclosure, and since the principle of solving the problem of the device in the embodiments of the present disclosure is similar to the service processing method described above in the embodiments of the present disclosure, the implementation of the device may refer to the implementation of the method, and repeated details are not described again.

Referring to fig. 9 and 10, fig. 9 is a first schematic diagram of a server according to an embodiment of the disclosure, and fig. 10 is a second schematic diagram of a server according to an embodiment of the disclosure. As shown in fig. 9, a server 900 provided by the embodiment of the present disclosure includes:

a service receiving module 910, configured to receive, in response to a trigger operation of a user on a target object, a service request sent by a client and initiated for the target object, where the service request includes an object address of the target object in a target process;

an object determining module 920, configured to determine the target object running in the target process based on the object address, where the target object is generated based on a pre-written class including service logic, the class inherits a base class of a preset object library, and a lock mechanism for multiple object services is added in the base class;

a service execution module 930, configured to control the target object to implement a target service corresponding to the service request according to a lock mechanism corresponding to the service request, where the class includes the target service, and the target service is registered in advance as being capable of being invoked by the outside and is bound with the corresponding lock mechanism.

In an optional embodiment, the service receiving module 910 generates the target object based on the following steps:

In an optional implementation manner, when the lock mechanism corresponding to the service request is a pessimistic lock, the service execution module 930 controls the target object to implement the target service corresponding to the service request according to the lock mechanism corresponding to the service request, and is specifically configured to:

determining a target service corresponding to the service request;

In an optional implementation manner, when the lock mechanism corresponding to the service request is an optimistic lock, the service execution module 930 controls the target object to implement the target service corresponding to the service request according to the lock mechanism corresponding to the service request, and is specifically configured to:

determining a target service corresponding to the service request;

adding a version number to the target service;

In an alternative embodiment, as shown in fig. 10, the server 900 further includes an address sending module 940 and a result sending module 950.

The address sending 940 module is configured to:

The result sending module 950 is configured to:

The description of the processing flow of each module in the device and the interaction flow between the modules may refer to the related description in the above method embodiments, and will not be described in detail here.

The server provided by the embodiment of the present disclosure, in response to a trigger operation of a user for a target object, receives a service request initiated for the target object and sent by a client, where the service request includes an object address of the target object in a target process; determining the target object running in the target process based on the object address, wherein the target object is generated based on a class which is written in advance and comprises business logic, the class inherits a base class of a preset object library, and a lock mechanism aiming at a plurality of object businesses is added in the base class; and controlling the target object to realize the target service corresponding to the service request according to a locking mechanism corresponding to the service request, wherein the class comprises the target service, and the target service is registered in advance as being capable of being called externally and is bound with the corresponding locking mechanism.

Based on the same inventive concept, an application generation device corresponding to the application generation method is also provided in the embodiments of the present disclosure, and since the principle of solving the problem of the device in the embodiments of the present disclosure is similar to the application generation method in the embodiments of the present disclosure, the implementation of the device may refer to the implementation of the method, and repeated details are not described again.

Referring to fig. 11, fig. 11 is a schematic diagram of an application generation apparatus according to an embodiment of the present disclosure. As shown in fig. 11, an application generation apparatus 1100 provided in an embodiment of the present disclosure includes:

an information obtaining module 1110, configured to obtain a class of a target object written by a user, an application logic of an application to be generated, and a preset object library, where the class includes a service logic of the target object;

a base class association module 1120, configured to associate the class with a base class of the object library, so as to control that the class can inherit the base class at runtime;

a lock mechanism adding module 1130, configured to add a lock mechanism for a plurality of object services in the base class;

a service registration module 1140, configured to register an object service that can be called externally in the base class from among the plurality of object services;

a file generating module 1150, configured to generate the application file of the application to be generated based on the processed object library, the class, and the application logic.

The application generation device provided by the embodiment of the present disclosure may obtain a class of a target object written by a user, an application logic of an application to be generated, and a preset object library, where the class includes a service logic of the target object, perform association processing on the class and a base class of the object library to control the class to inherit the base class during runtime, add a lock mechanism for a plurality of object services in the base class, register an object service that can be called externally in the plurality of object services in the base class, and generate an application file of the application to be generated based on the processed object library, the class, and the application logic.

Corresponding to the service processing method in fig. 5 and fig. 8 or the application generating method in fig. 2, an embodiment of the present disclosure further provides an electronic device 1200, as shown in fig. 12, a schematic structural diagram of the electronic device 1200 provided in the embodiment of the present disclosure includes:

a processor 1210, memory 1220, and bus 1230; the memory 1220 is used for storing instructions for execution and includes a memory 1221 and an external memory 1222; the memory 1221 is also referred to as an internal memory, and is used to temporarily store operation data in the processor 1210 and data exchanged with the external memory 1222 such as a hard disk, the processor 1210 exchanges data with the external memory 1222 through the memory 1221, and when the electronic device 1200 is operated, the processor 1210 communicates with the memory 1220 through the bus 1230, so that the processor 1210 executes the steps of the service processing method in fig. 5 and 8 or the steps of the application generation method in fig. 2.

The embodiments of the present disclosure also provide a computer-readable storage medium, where a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the computer program performs the steps of the service processing method or the application generation method described in the above method embodiments. The storage medium may be a volatile or non-volatile computer-readable storage medium.

The embodiments of the present disclosure also provide a computer program product, where the computer program product includes computer instructions, and when the computer instructions are executed by a processor, the steps of the service processing method or the application generating method in the foregoing method embodiments may be executed.

The computer program product may be implemented by hardware, software or a combination thereof. In an alternative embodiment, the computer program product is embodied in a computer storage medium, and in another alternative embodiment, the computer program product is embodied in a Software product, such as a Software Development Kit (SDK), or the like.

It can be clearly understood by those skilled in the art that, for convenience and brevity of description, the specific working processes of the server, the electronic device and the apparatus described above may refer to corresponding processes in the foregoing method embodiments, and are not described herein again. In the several embodiments provided in the present disclosure, it should be understood that the disclosed server, electronic device, apparatus and method may be implemented in other ways. The above-described embodiments of the apparatus are merely illustrative, and for example, the division of the units is only one logical division, and there may be other divisions when actually implemented, and for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection of devices or units through some communication interfaces, and may be in an electrical, mechanical or other form.

The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.

In addition, functional units in the embodiments of the present disclosure may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit.

The functions, if implemented in the form of software functional units and sold or used as a stand-alone product, may be stored in a non-volatile computer-readable storage medium executable by a processor. Based on such understanding, the technical solution of the present disclosure may be embodied in the form of a software product, which is stored in a storage medium and includes several instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the method according to the embodiments of the present disclosure. And the aforementioned storage medium includes: various media capable of storing program codes, such as a usb disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk, or an optical disk.

Finally, it should be noted that: the above-mentioned embodiments are merely specific embodiments of the present disclosure, which are used for illustrating the technical solutions of the present disclosure and not for limiting the same, and the scope of the present disclosure is not limited thereto, and although the present disclosure is described in detail with reference to the foregoing embodiments, those skilled in the art should understand that: any person skilled in the art can modify or easily conceive of the technical solutions described in the foregoing embodiments or equivalent technical features thereof within the technical scope of the present disclosure; such modifications, changes or substitutions do not depart from the spirit and scope of the embodiments of the present disclosure, and should be construed as being included therein. Therefore, the protection scope of the present disclosure shall be subject to the protection scope of the claims.

Claims

1. A method for processing a service, comprising:

2. The method according to claim 1, wherein before the receiving, in response to the user's trigger operation for the target object, the service request initiated for the target object sent by the client, the method comprises:

3. The method of claim 1, wherein the target object is generated based on:

4. The method according to claim 1, wherein when the lock mechanism corresponding to the service request is a pessimistic lock, controlling the target object to implement the target service corresponding to the service request according to the lock mechanism corresponding to the service request includes:

determining a target service corresponding to the service request;

5. The method according to claim 1, wherein when the lock mechanism corresponding to the service request is an optimistic lock, controlling the target object to implement the target service corresponding to the service request according to the lock mechanism corresponding to the service request includes:

determining a target service corresponding to the service request;

adding a version number to the target service;

6. The method according to claim 1, wherein after said controlling said target object to implement the target service corresponding to said service request according to the locking mechanism corresponding to said service request, said method comprises:

7. An application generation method, the method comprising:

acquiring a class of a target object written by a user, an application logic of an application to be generated and a preset object library, wherein the class comprises a service logic of the target object;

registering an object service capable of being called externally in the base class;

8. A server, characterized in that the server comprises:

and the service execution module is used for controlling the target object to realize the target service corresponding to the service request according to the locking mechanism corresponding to the service request, wherein the class comprises the target service, and the target service is registered in advance as being capable of being called externally and is bound with the corresponding locking mechanism.

9. An application generation apparatus, characterized in that the apparatus comprises:

10. An electronic device, comprising: a processor, a memory and a bus, the memory storing machine-readable instructions executable by the processor, the processor and the memory communicating over the bus when the electronic device is running, the machine-readable instructions when executed by the processor performing the steps of the business processing method of any one of claims 1 to 6 or the application generating method of claim 7.

11. A computer-readable storage medium, characterized in that the computer-readable storage medium has stored thereon a computer program which, when being executed by a processor, performs the steps of the service processing method according to any one of claims 1 to 6 or the application generation method according to claim 7.