Operation processing method, device, system and computer readable storage medium

Abstract

The application discloses an operation processing method, device and system and a computer readable storage medium. The method is applied to a formula engine client, and the formula engine client is deployed on a big data computing node. The method comprises the following steps: in response to receiving an operation request triggered by the big data computing node, determining a rule identifier corresponding to an operation rule required by the operation request; sending an operation rule acquisition request carrying the rule identifier to a formula engine server; receiving a target operation rule script corresponding to the rule identifier returned by the formula engine server; and executing the target operation rule script on a target calculation object corresponding to the operation request, and outputting an updated target calculation object. In this way, by combining the formula engine with big data, the object value can be quickly, dynamically and distributively adjusted according to the rules, so as to adapt to the computing requirements of real-time change and complex business scenarios.

Description

Technical Field

[0001] This invention relates to the field of big data technology, and in particular to a computing processing method, apparatus, system, and computer-readable storage medium. Background Technology

[0002] Big data needs to respond quickly to business changes when dealing with complex business scenarios. For example, for business indicator fields such as accounts receivable, actual receipts, outstanding payments, overdue payments, open interest, and cash collection, it needs to support flexible and ever-changing business judgments and rules, which cannot be supported by big data technology alone. Summary of the Invention

[0003] The purpose of this application is to provide a computational processing method, apparatus, system, and computer-readable storage medium that can quickly, dynamically, and in a distributed manner adjust object values ​​according to rules to adapt to the computational needs of real-time changing and complex business scenarios.

[0004] To achieve the above objectives:

[0005] In a first aspect, embodiments of this application provide a computational processing method applied to a formula engine client, wherein the formula engine client is deployed on a big data computing node; the method includes:

[0006] In response to receiving a computation request triggered by the big data computing node, determine the rule identifier corresponding to the computation rules required by the computation request;

[0007] Send a request to the formula engine server to obtain the operation rule carrying the rule identifier;

[0008] Receive the target operation rule script corresponding to the rule identifier returned by the formula engine server;

[0009] The target computation rule script is executed on the target computation object corresponding to the computation request, and the updated target computation object is output.

[0010] Optionally, the formula engine client includes a REST interface module, and sending a request to the formula engine server to obtain the calculation rule carrying the rule identifier includes:

[0011] Based on the REST interface module, a request to obtain the calculation rule carrying the rule identifier is sent to the formula engine server via the HTTP protocol.

[0012] Optionally, the formula engine client includes a parsing module and an execution module, wherein executing the target calculation rule script on the target calculation object corresponding to the calculation request includes:

[0013] The target operation rule script is parsed by the parsing module to obtain the target operation rule;

[0014] The execution module executes the target computation rule on the target computation object corresponding to the computation request to obtain the updated target computation object.

[0015] Secondly, embodiments of this application provide a calculation processing method applied to a formula engine server, wherein the formula engine server is deployed on a server, and the method includes:

[0016] Receive a request from the formula engine client to retrieve the calculation rules, which carries a rule identifier;

[0017] Based on the rule identifier, a preset operation rule library is queried to obtain the target operation rule script corresponding to the rule identifier;

[0018] The target calculation rule script is sent to the formula engine client.

[0019] Optionally, the method further includes:

[0020] In response to the setting command, the operation rule setting interface is output;

[0021] The system receives user configuration instructions through the operation rule setting interface and configures the operation rules according to the user configuration instructions.

[0022] Optionally, the formula engine server includes a REST service module, wherein receiving the calculation rule retrieval request carrying a rule identifier sent by the formula engine client includes:

[0023] The REST service module receives requests from the formula engine client for obtaining calculation rules, which carry rule identifiers.

[0024] Thirdly, embodiments of this application provide a computational processing method, the method comprising:

[0025] The formula engine client deployed on the big data computing node responds to the operation request triggered by the big data computing node, determines the rule identifier corresponding to the operation rule required by the operation request, and sends an operation rule acquisition request carrying the rule identifier to the formula engine server.

[0026] After receiving the request to obtain the operation rule, the formula engine server deployed on the server queries the preset operation rule library based on the rule identifier, obtains the target operation rule script corresponding to the rule identifier, and sends the target operation rule script to the formula engine client.

[0027] After receiving the target operation rule script, the formula engine client executes the target operation rule script on the target computation object corresponding to the operation request and outputs the updated target computation object.

[0028] Fourthly, embodiments of this application provide a computational processing system, including a formula engine client and a formula engine server. The formula engine client is deployed on a big data computing node, and the formula engine server is deployed on a server. The formula engine client is used to execute the computational processing method described in the first aspect, and the formula engine server is used to execute the computational processing method described in the second aspect.

[0029] Fifthly, embodiments of this application provide a computing processing apparatus, including: a processor and a memory storing a computer program, wherein when the processor runs the computer program, the steps of the above-described computing processing method are implemented.

[0030] Sixthly, embodiments of this application provide a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the steps of the above-described arithmetic processing method.

[0031] The computational processing method, apparatus, system, and computer-readable storage medium provided in this application embodiment are applied to a formula engine client, which is deployed on a big data computing node. The method includes: responding to receiving a computation request triggered by the big data computing node, determining a rule identifier corresponding to the computation rule required by the computation request; sending a computation rule acquisition request carrying the rule identifier to a formula engine server; receiving a target computation rule script corresponding to the rule identifier returned by the formula engine server; executing the target computation rule script on the target computation object corresponding to the computation request, and outputting an updated target computation object. Thus, by combining the formula engine with big data, it is possible to quickly, dynamically, and distributedly adjust object values ​​according to rules to adapt to the computational needs of real-time changing and complex business scenarios. Attached Figure Description

[0032] Figure 1 Flowchart of the computation processing method provided in the embodiments of the present invention Figure 1 ;

[0033] Figure 2 Flowchart of the computation processing method provided in the embodiments of the present invention Figure 2 ;

[0034] Figure 3 Flowchart of the computation processing method provided in the embodiments of the present invention Figure 3 ;

[0035] Figure 4 This is a schematic diagram illustrating the separation of the formula engine server and the formula engine client in an embodiment of the present invention;

[0036] Figure 5 This is a schematic diagram of the architecture combining big data and formula engine in an embodiment of the present invention;

[0037] Figure 6 This is a schematic diagram comparing the object before and after updating in an embodiment of the present invention;

[0038] Figure 7 This is a schematic diagram illustrating the process of combining big data with a formula engine in an embodiment of the present invention;

[0039] Figure 8 This is a schematic diagram of the structure of the computing processing device provided in an embodiment of the present invention. Detailed Implementation

[0040] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings denote the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with this application. Rather, they are merely examples of apparatuses and methods consistent with some aspects of this application as detailed in the appended claims.

[0041] It should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes that element. Furthermore, components, features, and elements with the same names in different embodiments of this application may have the same meaning or different meanings, the specific meaning of which must be determined by its interpretation in that specific embodiment or further in conjunction with the context of that specific embodiment.

[0042] It should be understood that although the terms first, second, third, etc., may be used herein to describe various information, such information should not be limited to these terms. These terms are used only to distinguish information of the same type from one another. For example, without departing from the scope of this document, first information may also be referred to as second information, and similarly, second information may also be referred to as first information. Depending on the context, the word "if," as used herein, can be interpreted as "when," "when," or "in response to determination." Furthermore, as used herein, the singular forms "a," "an," and "the" are intended to also include the plural forms unless the context indicates otherwise. It should be further understood that the terms "comprising," "including," indicate the presence of the stated feature, step, operation, element, component, item, kind, and / or group, but do not exclude the presence, occurrence, or addition of one or more other features, steps, operations, elements, components, items, kinds, and / or groups. The terms "or" and "and / or" as used herein are to be interpreted as inclusive, or mean any one or any combination thereof. Therefore, "A, B, or C" or "A, B, and / or C" means "any one of the following: A; B; C; A and B; A and C; B and C; A, B, and C". Exceptions to this definition will only occur if the combination of elements, functions, steps, or operations is inherently mutually exclusive in some way.

[0043] It should be understood that although the steps in the flowcharts of this application's embodiments are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some of the steps in the figures may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times, and their execution order is not necessarily sequential, but can be performed alternately or in turn with other steps or at least a portion of the sub-steps or stages of other steps.

[0044] It should be noted that step designations such as S101 and S102 are used in this document for the purpose of more clearly and concisely describing the corresponding content, and do not constitute a substantial limitation on the order. In specific implementation, those skilled in the art may execute S102 first and then S101, etc., but these should all be within the protection scope of this application.

[0045] It should be understood that the specific embodiments described herein are merely illustrative of this application and are not intended to limit this application.

[0046] In the following description, the use of suffixes such as "module," "part," or "unit" to denote elements is solely for the purpose of illustrative purposes and has no specific meaning in itself. Therefore, "module," "part," or "unit" may be used interchangeably.

[0047] See Figure 1 This application provides a computational processing method, which can be executed by a computational processing device provided in this application. The computational processing device can be implemented in software and / or hardware. In this embodiment, the computational processing device is taken as a formula engine client deployed on a big data computing node. The computational processing method provided in this embodiment includes:

[0048] Step S101: In response to receiving the computation request triggered by the big data computing node, determine the rule identifier corresponding to the computation rule required by the computation request.

[0049] Optionally, when processing tasks, the big data computing node may need to update the computational object, i.e., adjust the attribute values ​​or attribute fields of the computational object. In this case, the big data computing node can send a computation request to the formula engine client, which in turn receives the computation request triggered by the big data computing node. It should be noted that the computation request may include information indicating the required computation rules, such as the rule identifier or name corresponding to the required computation rule. Furthermore, the computation request may also include the target computational object, i.e., the computational object whose attribute values ​​or attribute fields need to be updated. Based on the computation request, the formula engine client can determine the rule identifier corresponding to the computation rule required by the computation request. Here, the formula engine client can be viewed as a JAR file packaged from the functions separated from the formula engine and deployed on the big data computing node.

[0050] Step S102: Send a request to the formula engine server to obtain the operation rule carrying the rule identifier.

[0051] Optionally, since the formula engine client does not store the calculation rules, the formula engine client needs to send a calculation rule retrieval request carrying the rule identifier to the formula engine server in order to request the calculation rule corresponding to the rule identifier.

[0052] In one embodiment, the formula engine client includes a REST interface module, and sending a request to the formula engine server to obtain the calculation rule carrying the rule identifier includes:

[0053] Based on the REST interface module, a request to obtain the calculation rule carrying the rule identifier is sent to the formula engine server via the HTTP protocol.

[0054] Optionally, when the formula engine client needs to obtain the operation rule corresponding to the rule identifier, it can send a request for obtaining the operation rule carrying the rule identifier to the formula engine server via HTTP protocol using its own REST interface module. Since HTTP protocol is a universal protocol supported by most systems, decoupling and integration are relatively convenient, thus improving the speed of obtaining operation rules and further enabling rapid adjustment of object values.

[0055] Step S103: Receive the target operation rule script corresponding to the rule identifier returned by the formula engine server.

[0056] Optionally, the formula engine client receives the target operation rule script corresponding to the rule identifier returned by the formula engine server based on the operation rule retrieval request. It should be noted that the operation rule can be considered as a mathematical expression, such as calculation object c = calculation object a + calculation object b, or calculation object c = calculation object a - calculation object b, etc.

[0057] Step S104: Execute the target computation rule script on the target computation object corresponding to the computation request, and output the updated target computation object.

[0058] Optionally, after obtaining the target operation rule script corresponding to the rule identifier, the formula engine client can execute the target operation rule script on the target computation object corresponding to the operation request to update the attribute values ​​or attribute fields of the target computation object and output the updated target computation object to the big data computing node. It should be noted that the target computation object may be included in the operation request or may be sent separately by the big data computing node to the formula engine client; no specific limitation is made here. For example, assuming the target operation rule is a+2, where 'a' represents the computation object, the sum of the value of the target computation object and 2 is used as the updated value of the target computation object.

[0059] In one embodiment, the formula engine client includes a parsing module and an execution module. Executing the target computation rule script on the target computation object corresponding to the computation request includes:

[0060] The target operation rule script is parsed by the parsing module to obtain the target operation rule;

[0061] The execution module executes the target computation rule on the target computation object corresponding to the computation request to obtain the updated target computation object.

[0062] Optionally, the formula engine client can first parse the target operation rule script through the parsing module to obtain the target operation rule, and then execute the target operation rule on the target computation object corresponding to the operation request through the execution module to obtain the updated target computation object. Here, the parsing module can also be called a parser, and the execution module can also be called an executor.

[0063] In summary, the computational processing method provided in the above embodiments combines the formula engine with big data to enable rapid, dynamic, and distributed adjustment of object values ​​according to rules, thereby adapting to the computational needs of real-time changing and complex business scenarios.

[0064] The same inventive concept as the foregoing embodiments, see the following: Figure 2 This application provides a computational processing method, which can be executed by a computational processing device provided in this application. The computational processing device can be implemented in software and / or hardware. In this embodiment, the computational processing device is taken as a formula engine server deployed on a server. The computational processing method provided in this embodiment includes:

[0065] Step S201: Receive the calculation rule retrieval request carrying the rule identifier sent by the formula engine client.

[0066] Optionally, the formula engine server can be deployed on an HTTP server or similar platform. The formula engine server can receive requests from formula engine clients, carrying rule identifiers, either in real-time or intermittently. It should be noted that the formula engine server can distinguish between different formula engine clients using their respective identifiers. Here, the formula engine server can be viewed as a file packaged from the functions separated from the formula engine and deployed on an HTTP server.

[0067] In one embodiment, the formula engine server includes a REST service module, wherein receiving a request from the formula engine client to obtain an operation rule carrying a rule identifier includes:

[0068] The REST service module receives requests from the formula engine client for obtaining calculation rules, which carry rule identifiers.

[0069] Optionally, the formula engine server can receive the calculation rule retrieval request sent by the formula engine client carrying the rule identifier through its own REST service module, such as receiving the calculation rule retrieval request sent by the formula engine client through the HTTP protocol based on the REST service module, so as to achieve stable data transmission.

[0070] Step S202: Based on the rule identifier, query the preset operation rule library to obtain the target operation rule script corresponding to the rule identifier.

[0071] Optionally, the formula engine server may pre-store a computation rule library, which may include multiple computation rules and corresponding rule identifiers. The formula engine server queries the pre-set computation rule library based on the rule identifier in the computation rule retrieval request to obtain the target computation rule corresponding to the rule identifier, and then generates the target computation rule script. It should be noted that the computation rule can be considered as a mathematical expression, such as computation object c = computation object a + computation object b, or computation object c = computation object a - computation object b, etc.

[0072] Step S203: Send the target calculation rule script to the formula engine client.

[0073] Optionally, the formula engine server sends the target operation rule script to the formula engine client, such as by sending the target operation rule script to the formula engine client through the REST service module, so that the formula engine client can obtain the required target operation rule script.

[0074] In summary, the computational processing method provided in the above embodiments combines the formula engine with big data to enable rapid, dynamic, and distributed adjustment of object values ​​according to rules, thereby adapting to the computational needs of real-time changing and complex business scenarios.

[0075] In one embodiment, the method further includes:

[0076] In response to the setting command, the operation rule setting interface is output;

[0077] The system receives user configuration instructions through the operation rule setting interface and configures the operation rules according to the user configuration instructions.

[0078] Optionally, on the formula engine server, users can customize or modify calculation rules as needed. Optionally, after receiving an input setting command, the formula engine server can output a calculation rule setting interface, i.e., display the calculation rule setting interface. This interface provides function buttons for modifying and adding calculation rules, and displays the corresponding function setting interface upon triggering. After receiving the user configuration command through the calculation rule setting interface, the formula engine server configures the calculation rules according to the user configuration command and updates the calculation rule library using the configured calculation rules. In this way, calculation rules can be customized based on requirements, enabling immediate response to changes in requirements and further improving the ability to adapt to the computational needs of real-time changing and complex business scenarios.

[0079] Based on the same inventive concept as the foregoing embodiments, see [link / reference]. Figure 3 This application provides an embodiment of an arithmetic processing method, which includes:

[0080] Step S301: The formula engine client deployed on the big data computing node responds to the operation request triggered by the big data computing node, determines the rule identifier corresponding to the operation rule required by the operation request, and sends an operation rule acquisition request carrying the rule identifier to the formula engine server.

[0081] Optionally, when processing tasks, the big data computing node may need to update the computational object, i.e., adjust the attribute values ​​or attribute fields of the computational object. In this case, the big data computing node can send a computation request to the formula engine client, which in turn receives the computation request triggered by the big data computing node. It should be noted that the computation request may include information indicating the required computation rules, such as the rule identifier or name corresponding to the required computation rule. Furthermore, the computation request may also include the target computational object, i.e., the computational object whose attribute values ​​or attribute fields need to be updated. Based on the computation request, the formula engine client can determine the rule identifier corresponding to the computation rule required by the computation request. Here, the formula engine client can be packaged into a JAR file based on the implemented functionality for deployment on the big data computing node.

[0082] Optionally, since the formula engine client does not store the calculation rules, the formula engine client needs to send a calculation rule retrieval request carrying the rule identifier to the formula engine server in order to request the calculation rule corresponding to the rule identifier.

[0083] In one embodiment, the formula engine client includes a REST interface module, and sending a request to the formula engine server to obtain the calculation rule carrying the rule identifier includes:

[0084] Based on the REST interface module, a request to obtain the calculation rule carrying the rule identifier is sent to the formula engine server via the HTTP protocol.

[0085] Optionally, when the formula engine client needs to obtain the operation rule corresponding to the rule identifier, it can send a request for obtaining the operation rule carrying the rule identifier to the formula engine server via HTTP protocol using its own REST interface module. Since HTTP protocol is a universal protocol supported by most systems, decoupling and integration are relatively convenient, thus improving the speed of obtaining operation rules and further enabling rapid adjustment of object values.

[0086] Step S302: After receiving the operation rule acquisition request, the formula engine server deployed on the server queries the preset operation rule library based on the rule identifier, obtains the target operation rule script corresponding to the rule identifier, and sends the target operation rule script to the formula engine client.

[0087] Optionally, the formula engine server can be deployed on an HTTP server or similar platform. The formula engine server can receive requests from formula engine clients, carrying rule identifiers, either in real-time or intermittently. It should be noted that the formula engine server can distinguish between different formula engine clients using their respective identifiers.

[0088] In one embodiment, the formula engine server includes a REST service module, wherein receiving a request from the formula engine client to obtain an operation rule carrying a rule identifier includes:

[0089] The REST service module receives requests from the formula engine client for obtaining calculation rules, which carry rule identifiers.

[0090] Optionally, the formula engine server can receive the calculation rule retrieval request sent by the formula engine client carrying the rule identifier through its own REST service module, such as receiving the calculation rule retrieval request sent by the formula engine client through the HTTP protocol based on the REST service module, so as to achieve stable data transmission.

[0091] Optionally, the formula engine server may pre-store a computation rule library, which may include multiple computation rules and corresponding rule identifiers. The formula engine server queries the pre-set computation rule library based on the rule identifier in the computation rule retrieval request to obtain the target computation rule corresponding to the rule identifier, and then generates the target computation rule script. It should be noted that the computation rule can be considered as a mathematical expression, such as rule 1: calculation object c = calculation object a + calculation object b, rule 2: calculation object c = calculation object a - calculation object b, etc.

[0092] Optionally, the formula engine server sends the target operation rule script to the formula engine client, such as by sending the target operation rule script to the formula engine client through the REST service module, so that the formula engine client can obtain the required target operation rule script.

[0093] Step S303: After receiving the target operation rule script, the formula engine client executes the target operation rule script on the target calculation object corresponding to the operation request and outputs the updated target calculation object.

[0094] Optionally, after obtaining the target operation rule script corresponding to the rule identifier, the formula engine client can execute the target operation rule script on the target computation object corresponding to the operation request to update the attribute values ​​or attribute fields of the target computation object and output the updated target computation object to the big data computing node. It should be noted that the target computation object may be included in the operation request or may be sent separately by the big data computing node to the formula engine client; no specific limitation is made here. For example, assuming the target operation rule is a+2, where 'a' represents the computation object, the sum of the value of the target computation object and 2 is used as the updated value of the target computation object.

[0095] In one embodiment, the formula engine client includes a parsing module and an execution module. Executing the target computation rule script on the target computation object corresponding to the computation request includes:

[0096] The target operation rule script is parsed by the parsing module to obtain the target operation rule;

[0097] The execution module executes the target computation rule on the target computation object corresponding to the computation request to obtain the updated target computation object.

[0098] Optionally, the formula engine client can first parse the target operation rule script through the parsing module to obtain the target operation rule, and then execute the target operation rule on the target computation object corresponding to the operation request through the execution module to obtain the updated target computation object.

[0099] In summary, the computational processing method provided in the above embodiments combines the formula engine with big data to enable rapid, dynamic, and distributed adjustment of object values ​​according to rules, thereby adapting to the computational needs of real-time changing and complex business scenarios.

[0100] In one embodiment, the method further includes:

[0101] The formula engine server responds to the setting command by outputting an operation rule setting interface; and receives user configuration commands through the operation rule setting interface, and configures the operation rules according to the user configuration commands.

[0102] Optionally, on the formula engine server, users can customize or modify calculation rules as needed. Optionally, after receiving an input setting command, the formula engine server can output a calculation rule setting interface, i.e., display the calculation rule setting interface. This interface provides function buttons for modifying and adding calculation rules, and displays the corresponding function setting interface upon triggering. After receiving the user configuration command through the calculation rule setting interface, the formula engine server configures the calculation rules according to the user configuration command and updates the calculation rule library using the configured calculation rules. In this way, calculation rules can be customized based on requirements, enabling immediate response to changes in requirements and further improving the ability to adapt to the computational needs of real-time changing and complex business scenarios.

[0103] Based on the same inventive concept as the foregoing embodiments, this application also provides a computational processing system, including a formula engine client and a formula engine server. The formula engine client is deployed on a big data computing node, and the formula engine server is deployed on a server. The formula engine client and the formula engine server are respectively used to execute the corresponding computational processing methods described in the foregoing embodiments.

[0104] Based on the same inventive concept as the foregoing embodiments, the foregoing embodiments will be described in detail below through a specific example.

[0105] To integrate the big data computing framework with the formula engine for distributed computing of inline data, the processing method provided in this embodiment first requires separating the formula engine server and the formula engine client. That is, the formula engine is functionally divided into two projects: a server-side project and a client-side project. (See [reference]). Figure 4 The server-side project is responsible for user management, permission management, indicator management, configuration management, predefined formulas, and providing REST services. The project is packaged and deployed on an HTTP server to provide services. The client-side project is a Java project whose main function is to pull calculation rules from the server through a REST client, parse and execute the calculation rules, and obtain the results. The project is packaged into a JAR file to support deployment.

[0106] See Figure 5This diagram illustrates a framework combining big data and a formula engine. The formula engine server runs on an HTTP server, providing web-based visual rule configuration. It has a rule library with multiple levels (level 1, 2, 3, etc.) for easy management and use. The formula engine client is written and compiled in Java, implements a serialization interface, is packaged into a JAR file, and deployed on big data computing nodes. It is loaded and invoked via the JVM, retrieving rule scripts from the formula engine server via HTTP, and then parsing and executing these scripts using a parser and executor. The big data computing nodes are where the actual computations are performed. On these nodes, computable objects that require rule execution are created. These computable objects have attribute fields reflecting business logic. The computable objects are passed to the formula engine client. After receiving the rule scripts and computable objects, the client executes the rule scripts and updates the attribute fields of the computable objects. Thus, the big data computing nodes obtain the updated computable objects according to the rules.

[0107] See Figure 6 For example, suppose the attribute value of order object A before the update is 100, and the operation rule is to multiply the value by 2. Then, after the rule is executed, the attribute value of object A is 100*2=200. The attribute value of order object B before the update is 100, and the operation rule is to divide the value by 2. Then, after the rule is executed, the attribute value of object B is 100 / 2=50.

[0108] The following example illustrates the combination of big data and formula engine for calculation.

[0109] See Figure 7 Assume the formula engine server is configured with 3 rules, as follows:

[0110] Rule 1: c = a + b, the sum of a and b is assigned to c;

[0111] Rule 2: c = ab, the difference between a and b is assigned to c;

[0112] Rule 3: c = a * b, the product of a and b is assigned to c.

[0113] The big data computing node obtains the above three rule scripts through the formula engine client, and then passes the created object and rule script to the parser and executor of the formula engine client, and obtains the updated object after parsing and execution.

[0114] For rule 1, if the object's attributes a = 100, b = 100, and c = 0, then after executing the rule, the object's attribute c = 200.

[0115] For rule 2, if the object's attributes a = 400, b = 100, and c = 0, then after executing the rule, the object's attribute c = 300.

[0116] For rule 3, if the object's attributes a = 50, b = 8, and c = 0, then after executing the rule, the object's attribute c = 400.

[0117] It should be noted that the big data computing frameworks involved in this application are not limited to SPARK and FLINK, and other big data computing frameworks that support serialization and deserialization of objects are also supported.

[0118] In summary, the computational processing method provided in this embodiment can obtain the formula engine calculation rule script via the HTTP protocol, and execute the rule script in a distributed manner on big data computing nodes to update internal objects, responding instantly to changes in requirements. The calculation rules can be edited and modified in a web interface, and the client is easy to deploy, requiring only a single JAR file. Furthermore, it creatively combines big data computing framework and formula engine technologies to create a synergistic effect, enabling rapid, dynamic, and distributed adjustment of object values ​​according to rules to adapt to real-time changes and complex business scenarios.

[0119] Based on the same inventive concept as the foregoing embodiments, this embodiment of the invention provides a computational processing device, such as... Figure 8 As shown, the device includes: a processor 310 and a memory 311 storing a computer program; wherein, Figure 8 The processor 310 shown in the diagram does not indicate that there is only one processor 310, but only indicates the positional relationship of the processor 310 relative to other devices. In practical applications, there can be one or more processors 310; similarly, Figure 8 The memory 311 illustrated herein has the same meaning, that is, it is only used to indicate the positional relationship of memory 311 relative to other devices. In practical applications, there can be one or more memories 311. When the processor 310 runs the computer program, it implements the arithmetic processing method applied to the above-described device.

[0120] The device may also include at least one network interface 312. The various components of the device are coupled together via a bus system 313. It is understood that the bus system 313 is used to implement communication between these components. In addition to a data bus, the bus system 313 also includes a power bus, a control bus, and a status signal bus. However, for clarity, in... Figure 8 The general designated all buses as Bus System 313.

[0121] The memory 311 can be volatile memory or non-volatile memory, or both. The non-volatile memory can be read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), ferromagnetic random access memory (FRAM), flash memory, magnetic surface memory, optical disc, or compact disc read-only memory (CD-ROM); the magnetic surface memory can be disk storage or magnetic tape storage. The volatile memory can be random access memory (RAM), which is used as an external cache. By way of example, but not limitation, many forms of RAM are available, such as Static Random Access Memory (SRAM), Synchronous Static Random Access Memory (SSRAM), Dynamic Random Access Memory (DRAM), Synchronous Dynamic Random Access Memory (SDRAM), Double Data Rate Synchronous Dynamic Random Access Memory (DDRSDRAM), Enhanced Synchronous Dynamic Random Access Memory (ESDRAM), SyncLink Dynamic Random Access Memory (SLDRAM), and Direct Rambus Random Access Memory (DRRAM).The memory 311 described in the embodiments of the present invention is intended to include, but is not limited to, these and any other suitable types of memory.

[0122] The memory 311 in this embodiment of the invention is used to store various types of data to support the operation of the device. Examples of such data include: any computer programs used to operate on the device, such as operating systems and applications; contact data; phonebook data; messages; pictures; videos, etc. The operating system includes various system programs, such as the framework layer, core library layer, driver layer, etc., used to implement various basic services and handle hardware-based tasks. Applications can include various applications, such as media players, browsers, etc., used to implement various application services. Here, the program implementing the method of this embodiment of the invention can be included in the application.

[0123] Based on the same inventive concept as the foregoing embodiments, this embodiment also provides a computer storage medium storing a computer program. The computer storage medium can be a magnetic random access memory (FRAM), a read-only memory (ROM), a programmable read-only memory (PROM), an erasable programmable read-only memory (EPROM), an electrically erasable programmable read-only memory (EEPROM), a flash memory, a magnetic surface memory, an optical disc, or a compact disc read-only memory (CD-ROM), etc.; it can also be various devices including one or any combination of the above-mentioned memories, such as mobile phones, computers, tablet devices, personal digital assistants, etc. When the computer program stored in the computer storage medium is executed by a processor, it implements the computational processing method applied to the above-mentioned device. For the specific steps implemented when the computer program is executed by the processor, please refer to [reference needed]. Figure 1-2 The description of the illustrated embodiments will not be repeated here.

[0124] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0125] In this document, the terms “comprising,” “including,” or any other variations thereof are intended to cover non-exclusive inclusion, which includes not only the elements listed but also other elements not expressly listed.

[0126] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. An arithmetic processing method characterized by comprising: The method is applied to a formula engine client deployed on a big data computing node, and comprises the following steps: In response to receiving an operation request triggered by the big data computing node, determining a rule identifier corresponding to an operation rule required by the operation request; Sending an operation rule acquisition request carrying the rule identifier to a formula engine server; Receiving a target operation rule script corresponding to the rule identifier returned by the formula engine server; Executing the target operation rule script on a target computing object corresponding to the operation request, and outputting an updated target computing object.

2. The method of claim 1, wherein, The formula engine client comprises a REST interface module, and the step of sending the operation rule acquisition request carrying the rule identifier to the formula engine server comprises the following steps: Based on the REST interface module, sending the operation rule acquisition request carrying the rule identifier to the formula engine server through an HTTP protocol.

3. The method of claim 1, wherein, The formula engine client comprises a parsing module and an execution module, and the step of executing the target operation rule script on the target computing object corresponding to the operation request comprises the following steps: Analyzing the target operation rule script through the parsing module to obtain a target operation rule; Executing the target operation rule on the target computing object corresponding to the operation request through the execution module to obtain the updated target computing object.

4. An arithmetic processing method characterized by comprising: The method is applied to a formula engine server deployed on a server, and comprises the following steps: Receiving an operation rule acquisition request carrying a rule identifier sent by a formula engine client; Based on the rule identifier, querying a preset operation rule library to obtain a target operation rule script corresponding to the rule identifier; Sending the target operation rule script to the formula engine client.

5. The method of claim 4, wherein, The method further comprises the following steps: In response to a setting instruction, outputting an operation rule setting interface; Receiving a user configuration instruction through the operation rule setting interface, and configuring an operation rule according to the user configuration instruction.

6. The method of claim 4, wherein, The formula engine server comprises a REST service module, and the step of receiving the operation rule acquisition request carrying the rule identifier sent by the formula engine client comprises the following step: Receiving the operation rule acquisition request carrying the rule identifier sent by the formula engine client through the REST service module.

7. An arithmetic processing method characterized by comprising: The method comprises the following steps: The formula engine client deployed on the big data computing node determines a rule identifier corresponding to an operation rule required by an operation request triggered by the big data computing node in response to receiving the operation request, and sends an operation rule acquisition request carrying the rule identifier to a formula engine server; The formula engine server deployed on the server queries a preset operation rule library based on the rule identifier to obtain a target operation rule script corresponding to the rule identifier after receiving the operation rule acquisition request, and sends the target operation rule script to the formula engine client; The formula engine client receives the target operation rule script, executes the target operation rule script on a target computing object corresponding to the operation request, and outputs an updated target computing object.

8. An arithmetic processing system characterized by comprising: The formula engine client is deployed on a big data computing node, and the formula engine server is deployed on a server; wherein the formula engine client is used to execute the operation processing method in any one of claims 1-3, and the formula engine server is used to execute the operation processing method in any one of claims 4-6.

9. An arithmetic processing device, characterized by comprising: Comprise: A processor and a memory storing a computer program, wherein the steps of the operation processing method in any one of claims 1 to 6 are implemented when the processor runs the computer program.

10. A computer-readable storage medium, characterized in that, A computer program is stored, and the steps of the operation processing method in any one of claims 1 to 6 are implemented when the processor executes the computer program.

Images