CN112579156A

CN112579156A - Processing system, processing method, processing device and processing equipment of business event

Info

Publication number: CN112579156A
Application number: CN202011459550.1A
Authority: CN
Inventors: 刘智杰
Original assignee: Bigo Technology Singapore Pte Ltd
Current assignee: Bigo Technology Singapore Pte Ltd
Priority date: 2020-12-11
Filing date: 2020-12-11
Publication date: 2021-03-30

Abstract

The embodiment of the invention discloses a system, a method, a device and equipment for processing a service event. Wherein, this system includes: the system comprises an event management component, a code binding component and an event execution component, wherein each service event of the target application in operation is registered in the event management component; the code binding component is oriented to each registered service event in the event management component, and respectively binds intermediate service codes supporting multi-language compiling and converting in each permitted execution mode; and if the event execution component receives the trigger message of the target service event when the target application runs, executing the intermediate service code bound by the target service event in the allowed execution mode correspondingly by adopting each allowed execution mode. The technical scheme provided by the embodiment of the invention realizes multi-voice compiling and multi-mode execution of the service event, ensures the execution portability and expandability of the service event and improves the safety and high efficiency of target application operation.

Description

Processing system, processing method, processing device and processing equipment of business event

Technical Field

The embodiment of the invention relates to the technical field of data processing, in particular to a system, a method, a device and equipment for processing a business event.

Background

In the internet field, a large number of application programs have been developed for different service types, and when each application program executes a corresponding core service operation, a large number of bypass logics supporting the core service to be executed accurately are extended under the core service.

Currently, in the process of processing core services, an application program has the following three processing modes for service events specified under each bypass logic:

1) based on the development language of the core service code, the processing code of the service event under the bypass logic is compiled in the core service code, and the modified core service code is restarted, at the moment, the bypass logic is embedded into the core service, so that the core service code is easy to leak, and a certain stability risk exists during the execution of the core service.

2) The method is based on Lua or other scripting languages as the code language of the service event under the bypass logic, but the scripting language needs to be converted into the language of the core service, so that the development language of the script is limited, and the application program usually does not support the running of other scripting languages except the native language, so that the portability of the scripting code is poor.

3) The service events under each bypass logic triggered in the core service processing process are asynchronously sent to the Kafka message middleware in a message form, and then each service event in the Kafka message middleware is continuously processed through a message consumption process, so that decoupling of service event execution and core service processing can be realized, but only an asynchronous processing mode is supported, the processing result of each service event cannot be synchronously returned to the core service, and the execution efficiency of the core service is influenced.

Disclosure of Invention

The embodiment of the invention provides a system, a method, a device and equipment for processing a service event, which are used for realizing multi-voice compiling and multi-mode execution of the service event, ensuring the execution portability and expandability of the service event and improving the safety and the high efficiency of the operation of a target application.

In a first aspect, an embodiment of the present invention provides a system for processing a service event, where the system includes: the system comprises an event management component, a code binding component and an event execution component, wherein each service event of the target application in operation is registered in the event management component; wherein the content of the first and second substances,

the code binding component is used for binding intermediate service codes supporting multi-language compiling and converting in each permission execution mode for each service event registered in the event management component;

and if the event execution component receives a trigger message of the target service event when the target application runs, adopting each allowed execution mode to correspondingly execute the intermediate service code bound by the target service event in the allowed execution mode.

In a second aspect, an embodiment of the present invention provides a method for processing a service event, where the method is applied to the system for processing a service event in the first aspect, and the method includes the following non-sequentially executed steps:

binding intermediate service codes supporting multi-language compiling and converting under each permission execution mode by a code binding component facing each registered service event in an event management component;

if a trigger message of a target service event is received through an event execution component when a target application runs, correspondingly executing an intermediate service code bound by the target service event in each permitted execution mode when the target service event is registered through the event execution component;

and all service events of the target application runtime are registered in the event management component.

In a third aspect, an embodiment of the present invention provides a device for processing a service event, where the device is configured in the system for processing a service event described in the first aspect, and the device includes:

the code binding module is used for binding intermediate service codes supporting multi-language compiling and converting under each permission execution mode by the code binding component facing each registered service event in the event management component;

a service code execution module, configured to, if a trigger message of a target service event is received through an event execution component when a target application runs, correspondingly execute, through the event execution component, an intermediate service code in which the target service event is bound in a permitted execution mode, in each permitted execution mode when the target service event is registered;

In a fourth aspect, an embodiment of the present invention provides a computer device, where the computer device includes:

one or more processors;

storage means for storing one or more programs;

when the one or more programs are executed by the one or more processors, the one or more processors implement the method for processing the business event according to any embodiment of the present invention.

In a fifth aspect, an embodiment of the present invention provides a computer-readable storage medium, on which a computer program is stored, where the computer program, when executed by a processor, implements a method for processing a service event according to any embodiment of the present invention.

According to the processing system, the processing method, the processing device and the processing equipment for the business events, all business events existing in the running process of the target application are registered in the event management component, the code binding component faces each registered business event in the event management component, and intermediate business codes supporting multi-language compiling and converting are respectively bound in each permitted execution mode, so that resource isolation can be realized between the execution of the business events and the running process of the target application, multi-language compiling and multi-mode execution of the business events are realized, and the execution portability and expandability of the business events are ensured; meanwhile, if the trigger message of the target service event is received through the event execution component when the target application runs, each permitted execution mode of the target service event is adopted to correspondingly execute the intermediate service code bound by the target service event in the permitted execution mode, so that the influence on the running of the target application is avoided, and the safety and the efficiency of the running of the target application are improved.

Drawings

Other features, objects and advantages of the invention will become more apparent upon reading of the detailed description of non-limiting embodiments made with reference to the following drawings:

fig. 1 is a schematic architecture diagram of a business event processing system according to an embodiment of the present invention;

fig. 2 is a schematic structural diagram of a system for processing a service event according to a second embodiment of the present invention;

fig. 3 is a schematic structural diagram of a system for processing a service event according to a third embodiment of the present invention;

fig. 4 is a flowchart of a method for processing a service event according to a fourth embodiment of the present invention;

fig. 5 is a flowchart of a method for processing a service event according to a fifth embodiment of the present invention;

fig. 6 is a schematic structural diagram of a device for processing a service event according to a sixth embodiment of the present invention;

fig. 7 is a schematic structural diagram of a computer device according to a seventh embodiment of the present invention.

Detailed Description

The present invention will be described in further detail with reference to the accompanying drawings and examples. It is to be understood that the specific embodiments described herein are merely illustrative of the invention and are not limiting of the invention. It should be further noted that, for the convenience of description, only some of the structures related to the present invention are shown in the drawings, not all of the structures. In addition, the embodiments and features of the embodiments in the present invention may be combined with each other without conflict.

When each service application executes a corresponding core service operation, a large number of bypass logics for assisting the core service to be accurately executed are expanded under the core service, so in order to ensure the execution accuracy of the core service, in the service application running process, service events specified under each bypass logic generally need to be processed; at this time, the embodiment of the present invention may specially design a new event processing system for the service event specified by each existing bypass logic in any service application, and embed the new event processing system into the service application, so as to execute and manage the service code bound to each service event in the running process of the service application. At this time, in order to solve the problems of inclusion and portability of the development language, the embodiment of the present invention may adopt a middle bytecode technology (WebAssembly, WASM) that abstractly describes a code execution environment to solve; the WASM code is a machine code which smoothes different architectures, and compiled codes in a plurality of languages (such as Assembly script, C \ C + +, Rust, Golang, Python and the like) can be converted into the WASM code. Therefore, the embodiment of the invention can construct an event processing system supporting synchronization and asynchronization based on the WASM intermediate byte code, and embed the event processing system into the service application to realize multi-voice compiling and multi-mode execution of the service event, ensure the execution portability and expandability of the service event, and improve the safety and the efficiency of the operation of the service application.

Example one

Fig. 1 is a schematic architecture diagram of a system for processing a business event according to an embodiment of the present invention. The embodiment can be applied to the situation that when the core service is operated in any service application, the service event appointed by each bypass logic expanded by the core service is processed. Specifically, referring to fig. 1, the system 10 for processing the service event may include: an event management component 110, a code binding component 120, and an event execution component 130.

Wherein, each service event of the target application runtime is registered in the event management component 110; specifically, the code binding component 120 is configured to bind, for each service event registered in the event management component 110, an intermediate service code supporting multi-language compiling and converting in each permitted execution mode; if the event execution component 130 receives the trigger message of the target service event when the target application runs, the intermediate service code bound by the target service event in the permitted execution mode is correspondingly executed in each permitted execution mode.

Optionally, the target application in this embodiment may be a service application program which is developed under any internet service type and can be installed on a client, when a main core service operation is executed on the target application, a large amount of bypass logic for assisting the core service to be accurately executed may be extended, and at this time, in order to ensure the operation accuracy of the core service in the target application, in this embodiment, a service event generated under each bypass logic needs to be processed. At this time, in order to avoid negative impact on the operation of the core service due to processing of service practices under the bypass logic, in this embodiment, the core service and the service events under the bypass logic need to be isolated, so that the processing processes between the core service and the service events under the bypass logic do not affect each other, and therefore, for processing of the service events under each bypass logic, an execution code of a corresponding processing function is specially re-written for each service event to be isolated from the execution code of the core service, so that the core service and the service events under the bypass logic can be independently executed, and the execution code of the core service does not need to be modified, thereby ensuring the operation security and stability of the core service in the target application. Therefore, in this embodiment, an event processing apparatus, that is, the processing system 10 for a service event in the present embodiment, is specially designed for the service event under the bypass logic in the target application, and the processing system 10 for the service event is embedded in the target application, so that when a certain service event in the target application is triggered, the execution code rewritten for the service event can be run to obtain the processing result of the service event.

In this embodiment, in order to accurately know each service event generated during the running of the target application, each bypass logic expanded under the core service during the running of the target application is analyzed in advance, then the service event generated under each bypass logic is judged, and each service event is registered in the event management component 110, so that the service event under each bypass logic expanded by the core service during the running of the target application is checked through the event management component 110 in the following process, and a corresponding execution code is specially written for the function of each service event. At this time, when the execution code of each service event is written by using the specific scripting language, the target application usually does not support the operation of other scripting languages except the native language, so that the portability of the execution code written by using the specific scripting language is poor, and therefore, in order to improve the portability of the execution code of the service event and improve the inclusion and openness of the code development language, in this embodiment, an intermediate service code supporting multi-language compiling conversion is selected to solve the problem of poor portability of the execution code.

Specifically, the developer views the service events under each bypass logic expanded by the core service in the runtime of the target application through the event management component 110, after analyzing the event function of each business event, corresponding original execution codes are specially written for each business event by adopting any language, meanwhile, in order to ensure the portability of the service event code, the original execution code is converted into an intermediate service code in the WASM language supporting multi-language compiling and converting, furthermore, the code binding component 120 faces each service event registered in the event management component 110, binds each intermediate service code written for the service event, and subsequently searches for the intermediate service code representing the function of each service event through the binding relationship between each service event and the intermediate service code, and ensures accurate processing of service practice by running the intermediate service code.

Meanwhile, because the event functions represented by the intermediate service codes written under each service event may or may not have any association, the execution modes of the intermediate service codes under each service event are also different, the allowable execution mode allowed to be adopted when the intermediate service codes are operated under each service event can be determined by analyzing the association between the event functions possessed by each service event, meanwhile, when the corresponding intermediate service codes are written aiming at the event functions of each service event, the actual execution mode of each intermediate service code can be defined, the actual execution mode of each intermediate service code written under each service event is analyzed by the code binding component 120, and the intermediate service codes are bound to the allowable execution mode with the same execution mode under the service event according to the actual execution mode of each intermediate service code under the service event, that is, in each permitted execution mode of each service event, an intermediate service code supporting actual execution by the permitted execution mode is bound.

It should be noted that the permitted execution mode of the service event in this embodiment may include at least one of a synchronous execution mode and an asynchronous execution mode. At this time, under the synchronous execution mode of the service event, a part of intermediate service codes are bound, and under the asynchronous execution mode of the service event, a part of intermediate service codes are also bound, so that multi-voice compiling and multi-mode execution of the service event are realized, and the execution portability and the expandability of the service event are ensured.

Further, in the running process of the target application, the corresponding service event is triggered and executed continuously, at this time, if a trigger message of a certain target service event is received through the event executing component 130, the code binding component 120 is directly used to find out each intermediate service code of the target service event which is bound under each permitted executing mode, and then each permitted executing mode is used to correspondingly execute each intermediate service code of the target service event which is bound under the permitted executing mode; for example, the intermediate service codes bound by the target service event in the synchronous execution mode are synchronously executed, and the intermediate service codes bound by the target service event in the asynchronous execution mode are asynchronously executed.

For example, when synchronously executing the intermediate service codes bound by the target service event in the synchronous execution mode, each intermediate service code bound in the synchronous execution mode may be sequentially run according to the binding sequence of each intermediate service code in the synchronous execution mode; when asynchronously executing each intermediate service code bound by the target service event in the asynchronous execution mode, an independent thread can be specially started, and each intermediate service code bound in the asynchronous execution mode is operated by adopting the independent thread. And then, feeding back the execution result of each intermediate service code bound under the target service event to the target application so as to ensure the accurate operation of the target application.

It should be noted that the code binding process and the code execution process in this embodiment belong to two stages of service event processing, the code binding process is completed in the development stage of the processing system 10 of the service event in this embodiment, after corresponding intermediate service codes are respectively bound for the service events under each bypass logic in the target application in each permitted execution mode, the processing system 10 of the service event can be embedded in the target application, and the trigger messages of each service event are received in real time by the event execution component 130 in the operation process of the target application, so that the code execution process of the target service event is executed in the application operation stage, thereby implementing accurate processing of the service event under each bypass logic in the target application, and further improving the execution portability and extensibility of the service event on the basis of ensuring the operation accuracy of the core service in the target application, and the security and efficiency of the running of the target application.

According to the technical scheme provided by the embodiment, each service event existing in the running process of the target application is registered in the event management component, and the code binding component is used for binding intermediate service codes supporting multi-language compiling and converting in each permitted execution mode for each registered service event in the event management component, so that resource isolation can be realized between the execution of the service event and the running process of the target application, multi-voice compiling and multi-mode execution of the service event are realized, and the execution portability and expandability of the service event are ensured; meanwhile, if the trigger message of the target service event is received through the event execution component when the target application runs, each permitted execution mode of the target service event is adopted to correspondingly execute the intermediate service code bound by the target service event in the permitted execution mode, so that the influence on the running of the target application is avoided, and the safety and the efficiency of the running of the target application are improved.

Example two

Fig. 2 is a schematic structural diagram of a system for processing a service event according to a second embodiment of the present invention. The embodiment is optimized on the basis of the technical scheme provided by the embodiment. Referring to fig. 2, the system for processing business events 20 may include an event management component 210, a code binding component 220, and an event execution component 230.

Wherein, each service event of the target application runtime is registered in the event management component 210; specifically, the code binding component 220 is oriented to each service event registered in the event management component 210, and respectively binds intermediate service codes supporting multi-language compiling and converting in each permitted execution mode; if the event execution component 230 receives the trigger message of the target service event when the target application runs, the intermediate service code bound by the target service event in the permitted execution mode is correspondingly executed in each permitted execution mode.

It should be noted that the event management component 210, the code binding component 220, and the event execution component 230 in the present embodiment have the same functions as those of the event management component, the code binding component, and the event execution component in the above embodiments.

Specifically, in order to ensure accurate registration of each business event in the target application in the development phase and accurate triggering in the running phase, the event management component 210 in this embodiment may include an event registration interface (register) 211 and an event triggering interface (Trigger) 212.

The event registration interface 211 registers each service event of the target application runtime by using an event identifier and a permission execution mode; the event trigger interface 212 detects the trigger status of each service event in real time according to the event identifier and the event trigger condition, and sends a trigger message of the target service event to the event execution component 230.

Optionally, the event registration interface 211 is mainly used for registering each service event generated when the target application runs, at this time, an event identifier (such as an event name, etc.) of the service event and a permitted execution mode allowed when each intermediate service code runs under the service event are used as interface input definitions of the event registration interface 211, so that the registration information of each service event is continuously input through the event registration interface 211, and simultaneously, interface output of the event registration interface 211 is defined as registration success or registration failure and a failure reason, thereby ensuring accurate registration of the service event.

Meanwhile, the event trigger interface 212 is mainly used for detecting whether a target service event triggered to be executed exists in real time in a target application running stage, at this time, interface input of the event trigger interface 212 is defined as an event identifier of the service event, an event trigger condition (for example, specific information triggered by a current event encapsulated by JSON codes), a callback processing method of an execution result of each intermediate service code under the target service event, and the like, at this time, input of the callback processing method can be a processing result of the target service event under JSON decoding encapsulation, a trigger state of each service event is judged by detecting interface input information in real time through the event trigger interface 212, and interface output of the event trigger interface 212 is defined as none, so that the trigger state of each service event in the target application running process is accurately detected, and when the target service event is detected to be triggered, a trigger message of the target service event is sent to the event execution component 230 so as to execute each intermediate service code bound under the target service event through the event execution component 230.

In addition, for the binding of each service event and the intermediate service code, the method mainly includes receiving the intermediate service code written for each service event in advance, determining an actual execution mode of the intermediate service code, and associating the service event with the intermediate service code, so that the intermediate service code written for each service event can be accurately found out in the following, and therefore, in order to ensure the accuracy of the binding relationship between the service event and the intermediate service code, the code binding component 220 in this embodiment may include a binding interface (Bind)221, a binding removal interface (Remove)222, and a code upgrading interface (Upgrade) 223.

The binding interface 221 binds the corresponding intermediate service code under each permitted execution mode for each service event according to the event identifier, the code identifier, the actual execution mode and the code word throttling; the binding removal interface 222 removes the bound intermediate service codes of each service event in the corresponding permitted execution mode according to the event identifier, the code identifier and the actual execution mode; the code upgrading interface 223 updates the bound intermediate service codes of each service event according to the code identification and the code upgrading byte stream.

Specifically, the binding interface 221 is mainly used for receiving each intermediate service code written for each service event and the service event pointed by the intermediate service code, at this time, the interface input of the binding interface 221 may be defined as an event identifier of the service event to be bound, a code identifier of the entered intermediate service code, an actual execution mode of the intermediate service code, a code byte stream of the intermediate service code, and the like, and the code word stream may be a binary byte stream of the WASM code; at this time, according to the interface input information, each intermediate service code may be continuously bound in each permitted execution mode of each service event, and an extension method name on which the intermediate service code depends may also be input in the interface input of the binding interface 221, so that when a corresponding virtual environment is subsequently created in the target application, an extension method corresponding to each intermediate service code may be loaded, thereby ensuring the execution efficiency of the intermediate service code. Meanwhile, the interface output of the binding interface 221 is defined as the binding success or the binding failure and the reason of the failure, so as to ensure the accurate binding between the service event and the intermediate service code.

In addition, in order to support the effective update of the intermediate service code bound to each service event, in this embodiment, some failed binding relationships are deleted through the binding removal interface 222, at this time, the interface input of the binding removal interface 222 is defined as the event identifier of the service event, the code identifier of the bound intermediate service code, and the actual execution mode of the intermediate service code, at this time, the above-mentioned interface inputs information, an intermediate service code to be removed can be correspondingly found under the same permitted execution mode as the actual execution mode in the service event, then directly removing the code information of the intermediate service code in the binding relationship under the service event, and defines the interface output of the binding removal interface 222 as the successful removal or the failure removal and the reason for the failure, thereby ensuring the effective update of the intermediate service code bound by each service event.

Meanwhile, in order to support the overall upgrade of the intermediate service codes bound to each service event, the present embodiment continuously updates the code content of each intermediate service code through the code upgrade interface 223, that is, the code word stream in the present embodiment, at this time, the interface input of the code upgrade interface 223 is defined as the code identifier of the intermediate service code to be upgraded, and the code upgrade byte stream to be upgraded and replaced, at this time, according to the above interface input information, the original code byte stream of the intermediate service code to be upgraded is replaced by the current code upgrade byte stream, and the interface output of the code upgrade interface 223 is defined as the upgrade success or upgrade failure and failure reason, thereby ensuring the comprehensiveness and accuracy of the upgrade of the intermediate service code.

Further, in order to accurately maintain the binding relationship between the service event and the intermediate service code, the processing system 20 of the service event of this embodiment may further include a storage component 240, where the storage component 240 records, in a key-value pair manner, the intermediate service code that has been bound in different permitted execution manners for each service event, and a code byte stream of the intermediate service code.

For example, the storage component 240 in this embodiment may partition a code list and a binding relationship list to store the code word throttling of the intermediate service code and the binding relationship between the intermediate service code and the service event in an isolated manner, at this time, the event identifier and the permission execution mode are used as key names in the binding relationship list, and the code identifier of the intermediate service code that has been bound by each service component in different permission execution modes is recorded; and recording the code byte stream of each bound intermediate service code of each service component by taking the code identifier as a key name in the code list. In addition, the name of the extension method on which each service component is bound and the respective intermediate service code depends is recorded in the code list.

Specifically, the event identifier and the permission execution mode of each service event are combined in the binding relationship list and unified as a key value, and then the value is set as the code identifier of each intermediate service code which is bound by the service event specified by the key value in the specific permission execution mode, so that the event identifier and the code identifier are associated, and the accurate binding relationship is obtained in each permission execution mode of each service event; meanwhile, each time the intermediate service code is bound for each service component, the code identifier of the bound intermediate service code is used as a key value in the code list, and then the value is set as the code byte stream of the intermediate service code specified by the key value, so that the code content of each intermediate service code is recorded in the code list in sequence.

According to the technical scheme provided by the embodiment, different functional interfaces are respectively set according to specific functions of the event management component and the code binding component, so that accurate registration of a service event before the operation of a target application and accurate trigger detection of the target service event after the operation process of the target application are ensured, resource isolation between the execution of the service event and the operation of the target application is realized, multi-voice compilation and multi-mode execution of the service event are realized, and the execution portability and expandability of the service event are ensured; meanwhile, a code list and a binding relation list are divided in the storage component to respectively store the code content of the intermediate service code and the binding relation between the intermediate service code and the service event, so that the code binding accuracy and the code updating convenience are ensured.

EXAMPLE III

Fig. 3 is a schematic structural diagram of a system for processing a service event according to a third embodiment of the present invention. The embodiment is optimized on the basis of the technical scheme provided by the embodiment. Referring to fig. 3, the system 30 for processing business events may include an event management component 310, a code binding component 320, and an event execution component 330.

Wherein, each service event of the target application runtime is registered in the event management component 310; specifically, the code binding component 320 binds, for each service event registered in the event management component 310, an intermediate service code supporting multi-language compiling and converting in each permitted execution mode; if the event execution component 330 receives the trigger message of the target service event when the target application runs, the intermediate service code bound by the target service event in the permitted execution mode is correspondingly executed in each permitted execution mode.

Meanwhile, the event management component 310 in the present embodiment may include an event registration interface 311 and an event trigger interface 312; the event registration interface 311 registers each service event of the target application in operation by using an event identifier and a permission execution mode; the event trigger interface 312 detects the trigger status of each service event in real time according to the event identifier and the event trigger condition, and sends a trigger message of the target service event to the event execution component 330.

Moreover, code binding component 320 can include a binding interface 321, a binding removal interface 322, and a code upgrade interface 323; wherein, the binding interface 321 binds the corresponding intermediate service code under each permitted execution mode for each service event according to the event identifier, the code identifier, the actual execution mode and the code word throttling; the binding removal interface 322 removes the bound intermediate service codes of each service event in the corresponding permitted execution mode according to the event identifier, the code identifier and the actual execution mode; the code upgrading interface 323 updates the intermediate service codes bound to each service event according to the code identifier and the code upgrading byte stream.

In addition, the system 30 for processing service events in this embodiment may further include a storage component 340, where the storage component 340 records, in a key-value pair manner, the intermediate service code that has been bound in different permitted execution manners for each service event, and a code byte stream of the intermediate service code. In particular, the storage component 340 may include a list of codes and a list of binding relationships; the binding relation list takes the event identifier and the permission execution mode as key names and records the code identifier of the bound intermediate service code of each service component in different permission execution modes; the code list takes the code identifier as a key name and records the code byte stream of each intermediate service code bound by each service component.

Further, in order to ensure accurate execution of each bound intermediate service code when the target service event is triggered and accurate binding of the intermediate service code in the running process of the target application, the service event processing system 30 of the embodiment may further include a virtual environment creating component 350 and a control center 360.

When the target application is started, the virtual environment creating component 350 creates a corresponding code virtual operating environment according to the execution configuration of each bound intermediate service code of each service event, and loads an extension method of each bound intermediate service code of each service event in the code virtual operating environment.

Specifically, in order to ensure that each bound intermediate service code is accurately executed after a target service event is triggered, in this embodiment, after a target application is started, the execution configuration of each intermediate service code that is bound to each service event, that is, virtual environment parameters and the like that need to be utilized when the intermediate service code successfully runs, is found in advance, so as to create a code virtual running environment suitable for each intermediate service code to successfully run, for example, a running controller, a running memory, whether to allow a thread to be started for execution, and the like, thereby ensuring the isolation and the safety of the intermediate service code running environment. Meanwhile, by searching the name of each extension method which is bound by each service event and depended on each intermediate service code, each extension method depended on by each intermediate service code can be pre-loaded into the created code virtual running environment, so that each intermediate service code can be directly run by directly adopting an externally called extension method in the following process, and the running accuracy of the intermediate service code is ensured.

In addition, the control center 360 develops corresponding initial service codes in multiple languages for each service event registered in the event management component 310, and converts the initial service codes into corresponding intermediate service codes so as to bind to the corresponding permitted execution mode of the service event.

Specifically, the control center 360 may display each service event registered in the event management component 310 and each intermediate service code currently bound to the service event through the operation interface, at this time, a developer may support writing a corresponding initial service code for each service event in multiple languages by checking a binding condition of the intermediate service code of each service event registered in the event management component 310, so as to develop the initial service code in multiple languages, and further correspondingly convert the initial service code into the intermediate service code supporting multi-language compiling and converting, so as to bind to a corresponding permitted execution mode of the service event, thereby ensuring portability of the execution code in the service event.

According to the technical scheme provided by the embodiment, each service event existing in the running process of the target application is registered in the event management component, the control center faces each registered service event in the event management component, the initial service code corresponding to multi-language development is adopted, the code binding component faces each registered service event in the event management component, and intermediate service codes supporting multi-language compiling and converting are respectively bound in each permitted execution mode, so that resource isolation can be realized between the execution of the service event and the running process of the target application, the multi-language compiling and multi-mode execution of the service event are realized, and the execution portability and expandability of the service event are ensured; meanwhile, when the target application is started, the virtual environment creating component creates corresponding code virtual operating environments for each intermediate service code, so that the operating accuracy of the intermediate service codes is ensured, and when the trigger message of the target service event is received by the event executing component during the operation of the target application, each permitted executing mode of the target service event is adopted to correspondingly execute the intermediate service codes bound by the target service event in the permitted executing mode, so that the influence on the operation of the target application is avoided, and the safety and the efficiency of the operation of the target application are improved.

Example 4

Fig. 4 is a flowchart of a method for processing a service event according to a fourth embodiment of the present invention, where this embodiment is applicable to a case where a service event specified under each bypass logic extended from a core service is processed when the core service is run in any service application. The method for processing a service event provided in this embodiment may be executed by a device for processing a service event provided in the embodiment of the present invention, where the device may be implemented in a software and/or hardware manner, and is integrated in a computer device for executing the method, where the computer device may be a terminal configured with a corresponding service application.

Specifically, referring to fig. 4, the method may include the following non-sequentially performed steps:

s410, binding intermediate service codes supporting multi-language compiling and converting under each permission execution mode by the code binding component facing each service event registered in the event management component.

In this embodiment, in order to accurately know each service event generated during the running of the target application, each bypass logic expanded under the core service during the running of the target application is analyzed in advance, then the service event generated under each bypass logic is judged, and each service event is registered in the event management component, so that the service event under each bypass logic expanded by the core service during the running of the target application is checked through the event management component in the following process, and a corresponding execution code is specially written for the function of each service event. At this time, in order to ensure the portability of the service event codes, intermediate service codes in the WASM language supporting multi-language compiling and converting are compiled for each service event, then the code binding component faces each service event registered in the event management component and respectively binds each intermediate service code compiled for the service event, and then the intermediate service codes representing the functions of each service event are searched through the binding relationship between each service event and the intermediate service codes, and the accurate processing of service practices is ensured by operating the intermediate service codes.

Meanwhile, because the event functions represented by the intermediate service codes written under each service event may or may not have any association, the execution modes of the intermediate service codes under each service event are different, the allowable execution mode which is allowed to be adopted when the intermediate service codes are operated under each service event can be determined by analyzing the association between the event functions possessed by each service event, meanwhile, when the corresponding intermediate service codes are written aiming at the event functions of each service event, the actual execution mode of each intermediate service code can be defined, the actual execution mode of each intermediate service code written under each service event is analyzed by the code binding component, and the intermediate service codes are bound under the allowable execution mode which is the same as the execution mode under the service event according to the actual execution mode of each intermediate service code under the service event, that is, in each permitted execution mode of each service event, an intermediate service code supporting actual execution by the permitted execution mode is bound.

At this time, for the binding of each service event and the intermediate service code, the method mainly includes receiving the intermediate service code written for each service event in advance, determining an actual execution mode of the intermediate service code, and associating the service event with the intermediate service code, so that the intermediate service code written for each service event can be accurately found out in the following, and therefore, in order to ensure the accuracy of the binding relationship between the service event and the intermediate service code, the code binding component in this embodiment may include a binding interface (Bind), a binding removal interface (Remove), and a code upgrading interface (Upgrade).

The binding interface binds corresponding intermediate service codes under each allowable execution mode for each service event according to the event identifier, the code identifier, the actual execution mode and the code word throttling; the binding removal interface removes the bound intermediate service codes of the service events in the corresponding permission execution mode according to the event identifier, the code identifier and the actual execution mode; and the code upgrading interface updates the bound intermediate service codes of each service event according to the code identification and the code upgrading byte stream, so that the accurate binding, binding updating and code upgrading between the service events and the intermediate service codes are ensured.

S420, if the trigger message of the target service event is received through the event execution component when the target application runs, the event execution component executes the intermediate service code bound by the target service event in each permitted execution mode when the target service event is registered.

Optionally, in the running process of the target application, the corresponding service event is triggered and executed continuously, at this time, if a trigger message of a certain target service event is received through the event executing component, each intermediate service code, which is respectively bound by the target service event in each permitted executing mode, is found directly through the code binding component, and then each permitted executing mode is adopted, each intermediate service code, which is bound by the target service event in the permitted executing mode, is executed correspondingly; for example, the intermediate service codes bound by the target service event in the synchronous execution mode are synchronously executed, and the intermediate service codes bound by the target service event in the asynchronous execution mode are asynchronously executed.

At this time, in order to ensure accurate registration of each service event in the target application in the development phase and accurate triggering in the running phase, the event management component in this embodiment may include an event registration interface (register) and an event triggering interface (Trigger). The event registration interface registers each service event of the target application operation by adopting an event identifier and a permission execution mode; and the event trigger interface detects the trigger state of each service event in real time according to the event identifier and the event trigger condition, and sends a trigger message of the target service event to the event execution component, so that the trigger accuracy of the target service event is ensured.

It should be noted that the method for processing a service event provided in this embodiment may be applied to a system for processing a service event provided in any embodiment of the present invention, and has the same function and beneficial effect.

EXAMPLE five

Fig. 5 is a flowchart of a method for processing a service event according to a fifth embodiment of the present invention. The embodiment is optimized on the basis of the embodiment. Specifically, as shown in fig. 5, this embodiment mainly explains in detail a specific binding process between a service event and an intermediate service code, and a specific execution process of each intermediate service code bound when a target service event is triggered.

Optionally, as shown in fig. 5, the present embodiment may include the following steps:

s510, binding intermediate service codes supporting multi-language compiling and converting under each permission execution mode by the code binding component facing each service event registered in the event management component.

S520, recording the bound intermediate service codes of each service event in different permitted execution modes and the code byte stream of the intermediate service codes by the storage component in a key value pair mode.

Optionally, in order to accurately maintain the binding relationship between the service event and the intermediate service code, the storage component may be divided into a code list and a binding relationship list, so as to store the code word throttling of the intermediate service code and the binding relationship between the intermediate service code and the service event in an isolated manner, at this time, the event identifier and the permission execution mode are used as key names in the binding relationship list, and the code identifier of the intermediate service code bound by each service component in different permission execution modes is recorded; and recording the code byte stream of each bound intermediate service code of each service component by taking the code identifier as a key name in the code list. In addition, the name of the extension method on which each service component is bound and the respective intermediate service code depends is recorded in the code list.

S530, when the target application is started, the virtual environment creating component creates a corresponding code virtual operating environment according to the execution configuration of each bound intermediate service code of each service event, and the extension method of each bound intermediate service code of each service event is loaded in the code virtual operating environment.

And S540, if the trigger message of the target service event is received through the event execution component when the target application runs, inquiring the bound intermediate service code of the target service event in each permitted execution mode from the code binding component through the event execution component.

Optionally, if, in the running process of the target application, the event execution component receives a trigger message of the target service event, which indicates that the target service event is triggered, and needs to run each intermediate service code bound to the target service event, to implement accurate processing of the target service event, at this time, the code binding component needs to first query the intermediate service codes bound to the target service event in each permitted execution mode, so that each permitted execution mode is subsequently adopted, and the intermediate service codes bound to the target service event in the permitted execution mode are correspondingly executed, thereby ensuring the processing accuracy of the service event.

And S550, correspondingly executing the intermediate service code bound by the target service event in each permitted execution mode when the event execution component adopts the target service event to register.

And S560, calling back the code execution result of the target service event in the synchronous execution mode through the event execution component, and sending the code execution result to the target application.

Optionally, after the execution of each intermediate service code bound to the target service event in each permitted execution mode is completed, in order to ensure accurate operation of the target application, the present embodiment may call back a code execution result of the target service event in the synchronous execution mode through the event execution component, so that the target application can be applied to a subsequent operation process of the target application, thereby implementing accurate operation of the kernel service in the target application.

EXAMPLE six

Fig. 6 is a schematic structural diagram of a service event processing apparatus according to a sixth embodiment of the present invention, which may be configured in a service event processing system according to any embodiment of the present invention. Specifically, as shown in fig. 6, the apparatus may include:

a code binding module 610, configured to bind, by the code binding component, intermediate service codes supporting multi-language compiling and converting in each permitted execution mode for each service event registered in the event management component;

a service code execution module 620, configured to, if a trigger message of a target service event is received through an event execution component when a target application runs, correspondingly execute, through the event execution component, an intermediate service code bound by the target service event in each permitted execution mode when the target service event is registered;

The processing apparatus for the service event provided in this embodiment is applicable to the processing method for the service event provided in any of the above embodiments, and has corresponding functions and beneficial effects.

EXAMPLE seven

Fig. 7 is a schematic structural diagram of a computer device according to a seventh embodiment of the present invention, as shown in fig. 7, the computer device includes a processor 70, a storage device 71, and a communication device 72; the number of the processors 70 in the computer device may be one or more, and one processor 70 is taken as an example in fig. 7; the processor 70, the storage means 71 and the communication means 72 in the computer device may be connected by a bus or other means, as exemplified by the bus connection in fig. 7.

The computer device provided by this embodiment can be used to execute the service event processing method provided by any of the above embodiments, and has corresponding functions and advantages.

Example eight

An eighth embodiment of the present invention further provides a computer-readable storage medium, on which a computer program is stored, where the computer program, when executed by a processor, can implement the method for processing the service event in any of the above embodiments. The method may specifically comprise the following non-sequentially performed steps:

Of course, the storage medium containing the computer-executable instructions provided by the embodiments of the present invention is not limited to the method operations described above, and may also perform related operations in the method for processing the service event provided by any embodiment of the present invention.

From the above description of the embodiments, it is obvious for those skilled in the art that the present invention can be implemented by software and necessary general hardware, and certainly, can also be implemented by hardware, but the former is a better embodiment in many cases. Based on such understanding, the technical solutions of the present invention may be embodied in the form of a software product, which can be stored in a computer-readable storage medium, such as a floppy disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a FLASH Memory (FLASH), a hard disk or an optical disk of a computer, and includes several instructions for enabling a computer device (which may be a personal computer, a server, or a network device) to execute the methods according to the embodiments of the present invention.

It should be noted that, in the embodiment of the processing apparatus for business events, the included units and modules are only divided according to functional logic, but are not limited to the above division, as long as the corresponding functions can be implemented; in addition, specific names of the functional units are only for convenience of distinguishing from each other, and are not used for limiting the protection scope of the present invention.

The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention, and various modifications and changes may be made by those skilled in the art. Any modification, equivalent replacement, or improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.

Claims

1. A system for processing a business event, comprising: the system comprises an event management component, a code binding component and an event execution component, wherein each service event of the target application in operation is registered in the event management component; wherein the content of the first and second substances,

2. The processing system of claim 1, wherein the event management component comprises an event registration interface and an event trigger interface; wherein the content of the first and second substances,

the event registration interface registers each business event of the target application operation by adopting an event identifier and a permission execution mode;

and the event trigger interface detects the trigger state of each business event in real time according to an event identifier and an event trigger condition, and sends a trigger message of the target business event to the event execution component.

3. The processing system of claim 1, wherein the code binding component comprises a binding interface, a binding removal interface, and a code upgrade interface; wherein the content of the first and second substances,

the binding interface binds corresponding intermediate service codes under each allowable execution mode for each service event according to the event identifier, the code identifier, the actual execution mode and the code word throttling;

the binding removal interface removes the bound intermediate service codes of the service events in the corresponding permission execution mode according to the event identifier, the code identifier and the actual execution mode;

and the code upgrading interface updates the bound intermediate service codes of each service event according to the code identification and the code upgrading byte stream.

4. The processing system of claim 1, wherein the permitted execution of the business event comprises at least one of a synchronous execution and an asynchronous execution.

5. The processing system of any of claims 1-4, further comprising a storage component;

the storage component records the bound intermediate service codes of each service event in different allowed execution modes and the code byte stream of the intermediate service codes in a key-value pair mode.

6. The processing system of claim 5, wherein the storage component comprises a list of code and a list of binding relationships; wherein the content of the first and second substances,

the binding relation list takes the event identifier and the permission execution mode as key names and records the code identifier of the bound intermediate service code of each service component in different permission execution modes;

and the code list takes the code identifier as a key name and records the code byte stream of each intermediate service code bound by each service component.

7. The processing system of any of claims 1-4, further comprising a virtual environment creation component;

and when the target application is started, the virtual environment creating component creates a corresponding code virtual operating environment according to the execution configuration of each bound intermediate service code of each service event, and loads each bound intermediate service code of each service event in the code virtual operating environment.

8. The processing system of any one of claims 1 to 4, further comprising a control center;

the control center adopts multilingual development corresponding initial service codes to each registered service event in the event management component, converts the initial service codes into corresponding intermediate service codes and binds the intermediate service codes to the corresponding permission execution mode of the service event.

9. The processing system of claim 8, wherein the control center exposes, via an operation interface, the intermediate service code bound to each service event registered in the event management component.

10. A method for processing a service event, applied in a system for processing a service event according to any one of claims 1 to 9, comprising the following non-sequentially executed steps:

11. The method of claim 10, wherein before executing, by the event execution component, the intermediate service code bound by the target service event in each permitted execution mode when the target service event is registered in the permitted execution mode, the method further comprises:

and inquiring the bound intermediate service code of the target service event in each permitted execution mode from the code binding component through the event execution component.

12. The method of claim 10, after binding intermediate service code supporting multi-language compilation and translation in each permitted execution mode for each service event registered in the event oriented management component by the code binding component, further comprising:

and recording the bound intermediate service codes of each service event in different permitted execution modes and the code byte stream of the intermediate service codes by adopting a key value pair mode through a storage component.

13. The method of claim 10, wherein after the event execution component employs each permitted execution mode of the target service event, and executes the intermediate service code bound by the target service event in the permitted execution mode, the method further comprises:

and calling back a code execution result of the target service event in a synchronous execution mode through the event execution component, and sending the code execution result to the target application.

14. The method according to any one of claims 10-13, further comprising:

when the target application is started, a virtual environment creating component is used for creating a corresponding code virtual operating environment according to the execution configuration of each bound intermediate service code of each service event, and an expansion method for loading each bound intermediate service code of each service event in the code virtual operating environment is adopted.

15. A transaction event processing apparatus, configured in the transaction event processing system according to any one of claims 1 to 9, comprising:

16. A computer device, characterized in that the computer device comprises:

one or more processors;

storage means for storing one or more programs;

when executed by the one or more processors, cause the one or more processors to implement a method of processing a business event as claimed in any one of claims 10-14.

17. A computer-readable storage medium, on which a computer program is stored, which program, when being executed by a processor, is adapted to carry out the method of processing a transaction event according to any one of claims 10 to 14.