CN108958796B - Service request processing method and device and service request processing system - Google Patents
Service request processing method and device and service request processing system Download PDFInfo
- Publication number
- CN108958796B CN108958796B CN201710367400.XA CN201710367400A CN108958796B CN 108958796 B CN108958796 B CN 108958796B CN 201710367400 A CN201710367400 A CN 201710367400A CN 108958796 B CN108958796 B CN 108958796B
- Authority
- CN
- China
- Prior art keywords
- code
- flow
- component container
- request
- dynamic
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000012545 processing Methods 0.000 title claims abstract description 23
- 238000003672 processing method Methods 0.000 title claims abstract description 9
- 238000000034 method Methods 0.000 claims abstract description 59
- 230000008569 process Effects 0.000 claims abstract description 35
- 230000003068 static effect Effects 0.000 claims description 30
- 230000014509 gene expression Effects 0.000 claims description 6
- 238000013515 script Methods 0.000 claims description 6
- 238000012546 transfer Methods 0.000 claims description 2
- 238000004590 computer program Methods 0.000 description 13
- 230000006870 function Effects 0.000 description 8
- 230000009471 action Effects 0.000 description 7
- 238000010586 diagram Methods 0.000 description 7
- 238000005516 engineering process Methods 0.000 description 7
- 230000005540 biological transmission Effects 0.000 description 3
- 230000008859 change Effects 0.000 description 3
- 238000011161 development Methods 0.000 description 3
- 238000012423 maintenance Methods 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000006399 behavior Effects 0.000 description 1
- 230000001413 cellular effect Effects 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 230000000295 complement effect Effects 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 230000005055 memory storage Effects 0.000 description 1
- 230000002085 persistent effect Effects 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/30003—Arrangements for executing specific machine instructions
- G06F9/30007—Arrangements for executing specific machine instructions to perform operations on data operands
- G06F9/30036—Instructions to perform operations on packed data, e.g. vector, tile or matrix operations
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/72—Code refactoring
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/38—Concurrent instruction execution, e.g. pipeline, look ahead
- G06F9/3836—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
Abstract
A service request processing method and device and a service request processing system, wherein the method comprises the following steps: the method comprises the steps that a flow engine receives a service request carrying a request parameter value sent by a request end; the flow engine determines a target flow template which comprises at least one flow object and corresponds to a request parameter value carried in the data request according to the flow template file; the process engine acquires and loads service codes corresponding to each process object in the target process template from a code component container, wherein the code component container stores pre-extracted universal code components and personalized code components, and codes in the code component container are updated in a dynamic deployment mode; and the flow engine sequentially executes the service codes according to the sequence of the flow objects in the target flow template, obtains an execution result and returns the execution result to the request end. The embodiment of the application can effectively promote maintainability and expandability of the flow engine.
Description
Technical Field
The present invention relates to the field of software development technologies, and in particular, to a service request processing method and apparatus, and a service request processing system.
Background
The Process Engine is used as part of the application system to provide core solutions of different decision information transmission routes, content levels and the like according to roles, division and conditions, wherein the decision information transmission routes, the division and the conditions are decided for each application system. In the related art, a flow engine may be deployed on an application server, and when new processing logic or functions need to be added, new implementation codes need to be developed for the new processing logic, and the new implementation codes are compiled and then deployed on the application server for updating and upgrading.
Disclosure of Invention
In view of the foregoing, the present application provides a service request processing method and apparatus, and a service request processing system.
In order to achieve the above purpose, the technical scheme provided by the application is as follows:
according to a first aspect of the present application, a service request processing method is provided, including:
the method comprises the steps that a flow engine receives a service request carrying a request parameter value sent by a request end;
the flow engine determines a target flow template which comprises at least one flow object and corresponds to a request parameter value carried in the data request according to a flow template file, wherein the flow template file comprises a predetermined corresponding relation between the flow template and the request parameter value;
the process engine acquires and loads service codes corresponding to each process object in the target process template from a code component container, wherein the code component container stores pre-extracted universal code components and personalized code components, and codes in the code component container are updated in a dynamic deployment mode;
and the flow engine sequentially executes the service codes according to the sequence of the flow objects in the target flow template, obtains an execution result and returns the execution result to the request end.
According to a second aspect of the present application, a service request processing device is provided, which is applied to a flow engine, and the device includes a request receiving unit, a flow template determining unit, a code obtaining unit, and a code executing unit, wherein:
the request receiving unit receives a service request carrying a request parameter value sent by a request end;
the flow template determining unit determines a target flow template which comprises at least one flow object and corresponds to a request parameter value carried in the data request according to a flow template file, wherein the flow template file comprises a corresponding relation between a predetermined flow template and the request parameter value;
the code acquisition unit acquires and loads service codes corresponding to all flow objects in the target flow template from a code component container, wherein the code component container stores pre-extracted universal code components and personalized code components, and codes in the code component container are updated in a dynamic deployment mode;
and the code executing unit sequentially executes the service codes according to the sequence of the flow objects in the target flow template, obtains an executing result and returns the executing result to the request end.
According to a third aspect of the present application, a service request processing system is provided, including a flow engine, a code update server, a static component container, and a dynamic component container;
the static component container stores universal code components, and the dynamic component container stores personalized code components;
the code updating server is used for updating codes in the dynamic component container in a dynamic deployment mode;
the flow engine comprises a request receiving unit, a flow template determining unit, a code obtaining unit and a code executing unit, wherein:
the request receiving unit receives a service request carrying a request parameter value sent by a request end;
the flow template determining unit determines a target flow template which comprises at least one flow object and corresponds to a request parameter value carried in the data request according to a flow template file, wherein the flow template file comprises a corresponding relation between a predetermined flow template and the request parameter value;
the code acquisition unit acquires service codes corresponding to each flow object in the target flow template from a static component container and a dynamic component container and loads the service codes;
and the code executing unit sequentially executes the service codes according to the sequence of the flow objects in the target flow template, obtains an executing result and returns the executing result to the request end.
According to the technical scheme, codes (universal code components) which can be used in different business scenes and personalized code components which cannot be used in all business scenes are abstracted, and the code components are stored in a code component container. In the process of processing the service request, a target flow template corresponding to the service request and containing at least one flow object can be determined according to the request parameter value carried in the service request, then a required service code is obtained from the code component container and loaded, and finally the service codes are sequentially executed according to the sequence of the flow objects in the target flow template, so that an execution result is obtained and returned to the request end. The embodiment of the application can effectively promote maintainability and expandability of the flow engine. In addition, in the embodiment of the application, the code in the code component container can be updated in a dynamic deployment mode, so that the flexibility of code deployment is improved by combining a flow engine technology and a dynamic deployment technology, the update and upgrade of new realization logic are completed under the condition of not restarting an application server, and the code development cost is reduced.
Drawings
FIG. 1 is a system architecture shown according to an exemplary embodiment;
FIG. 2 is a flow chart illustrating a method of service request processing according to an exemplary embodiment;
FIG. 3 is a hardware architecture of an electronic device, shown in accordance with an exemplary embodiment;
fig. 4 is a block diagram illustrating a service request processing apparatus according to an exemplary embodiment.
Detailed Description
FIG. 1 is a system architecture, shown in accordance with an exemplary embodiment, that may include: application server, code update server, static component container and dynamic component container. The application server is provided with a flow engine, the static component container and the dynamic component container can be persisted in a specific Database (Database), and the code update server is provided with a background management program for updating code components stored in the Database, wherein the Database can be accessed through SQL sentences to realize operations of adding, deleting, modifying and searching. The application server is used for receiving the service request sent by the request end, executing corresponding processing actions and returning corresponding processing results. For example, the request end may be an external system or a client device used by a user. The application server needs to meet the requirements of different service scenarios, and can be implemented by service requests containing different request parameter values for different service scenarios. In general, the business processes that the process engine needs to process are also different for different business scenarios. This determines the code that the flow engine needs to execute in different traffic scenarios. For this reason, in the embodiment of the present application, code components that can be used in common for at least two different service scenarios (referred to as "common code components") and code components that cannot be used in common for different service scenarios (referred to as "personalized code components") may be abstracted in advance, so that, for convenience in code management, the static component container may be used to store the common code components, and the dynamic component container may be used to store the personalized code components. After receiving the service request, the flow engine can obtain and execute the required code components from the static component container and the dynamic component container respectively. The implementation will be described in detail below in conjunction with fig. 2.
As shown in fig. 2, the method may be applied to a process engine, which may be deployed on an application server, for example, which may function to provide data services to the outside. In one embodiment, the method includes the following steps 101-104, wherein:
in step 101, a service request carrying a request parameter value sent by a requesting end is received.
For example, the request parameters in each service request from the requesting end are as follows:
"serviceType", "tradeType" and "sceneType";
where "serviceType" may represent a service type, "tradeType" may represent a transaction type, and "sceneType" may represent a scene type.
Each service request needs to include a value corresponding to each request parameter, for example, "serviceType" = "trans_in", "tradeType" = "pkg_ BUY", "sceneType" = "QIANBAO01".
In step 102, a target flow template including at least one flow object corresponding to the request parameter value carried in the data request is determined according to a flow template file, where the flow template file includes a predetermined correspondence between the flow template and the request parameter value.
Since different service scenarios correspond to different service flows, it is necessary to implement by different service requests. In the embodiment of the application, the business processes (including which processes, the order among the processes, etc.) that need to be executed by a certain business scenario may be described by a process template including at least one process object. Therefore, the corresponding relation between the flow template and the request parameter value needs to be determined in advance, so that the target flow template corresponding to the business request can be determined quickly after the business request is received.
For example, the code content in one exemplary flow template file describing the correspondence of flow templates and request parameter values is as follows:
through the code content, when the values of the request parameters "serviceType", "tradeType" and "sceneType" IN the service request are "trans_in", "pkg_ BUY" and "QIANBAO01", respectively, the matched target flow template is composed of the following flow objects (according to the sequence):
"PRO-TRANS-IN-PKG-BUY-INIT" (scheme one);
"PRO-TRANS-IN-PKG-BUY-PRECHECK" (scheme II);
"PRO-TRANS-IN-PKG-BUY-APPLY" (scheme III);
"PRO-TRANS-IN-PKG-BUY-CONFIRM" (scheme IV);
"PRO-TRANS-IN-SUCCESS-RESULT-RETURN" or
"PRO-TRANS-IN-FAIL-RESULT-RETURN" (scheme five).
After step 102, the flow engine needs to instantiate the flow objects contained in the target flow template. In object-oriented programming, the process of creating objects with classes is often referred to as instantiation.
The above exemplary code only enumerates a flow template under one service scenario, in the actual operation process, a developer may set corresponding flow templates for other service scenarios according to actual requirements in advance, and add the corresponding flow templates to the flow template file in the form of code, which is not specifically enumerated here. It should be noted that, according to the development of the service, the developer may dynamically adjust the correspondence in the flow template file, where dynamic adjustment refers to adjustment without restarting the application server. The developer can upload the modified flow template file to a database accessible by the flow engine, and when the flow engine senses the change, the flow engine can route the business flow according to the changed flow template file.
In step 103, service codes corresponding to the flow objects in the target flow template are obtained from a code component container and loaded, wherein the code component container stores pre-extracted universal code components and personalized code components, and codes in the code component container are updated in a dynamic deployment mode.
In an alternative embodiment, the code component container may include a static component container storing generic code components and a dynamic component container storing personalized code components; the codes in the dynamic component container are updated in a dynamic deployment mode. The dynamic deployment can also be called as hot deployment (hotstart), and the hot deployment can automatically detect the change of a code file and update the behavior of a running code on the premise of not restarting a service server. In the embodiment of the application, compared with a static component container, due to the fact that the code in the dynamic component container needs to be changed frequently, the later maintenance cost of the dynamic component container is high along with the increase of service complexity, and expansibility is also general. Therefore, in the embodiment of the application, by combining the static component container and the dynamic component container, certain code components in the dynamic component container, which can be multiplexed by at least two business scenes, are transferred to the static component container for persistent storage periodically or irregularly, so that the code components stored in the dynamic component container are reduced as much as possible, the code components for loading by a flow engine are stored in the static component container as much as possible, and the maintenance cost is reduced. In other embodiments, when an object code component has not changed for a longer period of time, the object code may also be transferred from the dynamic component container to the static component container. For some newly added service scenes or personalized codes for realizing logic, the newly added service scenes or personalized codes for realizing logic can be stored in the dynamic component container in a dynamic deployment mode, so that restarting of an application server is avoided, and uninterrupted service operation is ensured. In an embodiment, the generic code component is packed JAVA code (compiled JAVA code), and the personalized code component is JAVA class and/or dynamic script (e.g. a grovy script) and/or EL expression, etc. that need to be loaded dynamically.
Based on the above, in an alternative embodiment, step 103 may specifically include:
step 1031: the flow engine determines a universal code component and a personalized code component required by realizing the target flow template according to each flow object contained in the target flow template;
step 1032: a flow engine acquires the universal code component from the static component container;
step 1033: a flow engine obtains the personalized code component from the dynamic component container.
For example, the specific implementation code of each flow object in the target flow template is as follows:
wherein, the various process objects can be realized by one or more 'actions'. The implementation code of each "action" may be written in JAVA statements, and/or EL (Expression Language) expressions, and/or groovy scripts, etc. Taking the foregoing "action" as an example, the "action" can be divided into "action" (i.e. a generic component) that can be used by different service scenarios, and "action" (i.e. a personalized component) that cannot be used by different service scenarios. The developer may define in advance a corresponding tag for each code component that is abstracted to indicate whether it belongs to a generic component or a personalized component.
In the embodiment of the application, after the required universal component and the required personalized component are respectively acquired from the static component container and the dynamic component container, the acquired service codes can be loaded. The process of reading the code from the database into the memory of the application server is the loading process.
In step 104, the service codes are executed in sequence according to the sequence of the flow objects in the target flow template, and an execution result is obtained and returned to the request end.
The loaded service codes can be circularly executed according to the actual service requirement until the required execution result is obtained. Of course, if the execution result (execution exception) cannot be obtained, the corresponding exception information may be returned to the requesting end.
By the service request processing method, the codes which can be used universally and the personalized codes which cannot be used universally in different service scenes are abstracted and are respectively persisted into the static component container and the dynamic component container, so that maintainability and expandability of the flow engine can be effectively improved, maintenance cost is effectively reduced, and execution efficiency of the flow engine is improved to a certain extent. In addition, the code components in the dynamic component container can be updated in a dynamic deployment mode, so that the flexibility of code deployment is improved by combining a flow engine technology and a dynamic deployment technology, the update and upgrade of new realization logic are completed under the condition of not restarting an application server, and the code development cost is reduced.
Fig. 3 is a hardware structure of an electronic device, which is shown according to an exemplary embodiment. Referring to fig. 3, at a hardware level, the electronic device may be an application server deployed with a flow engine, where the application server may include a processor, an internal bus, a network interface, a memory (including a memory and a nonvolatile memory), and may include hardware required by other services. Wherein, the memory can store related logic (i.e. computer program) for implementing the service request processing method, and the processor can read the corresponding computer program from the nonvolatile memory into the memory and then run the corresponding computer program. Of course, other implementations, such as logic devices or combinations of hardware and software, are not excluded from the present application, that is, the execution subject of the following processing flows is not limited to each logic unit, but may be hardware or logic devices.
As shown in fig. 4, in an embodiment, a service request processing apparatus 200 may be applied to a flow engine, where the apparatus 200 may include a request receiving unit 201, a flow template determining unit 202, a code obtaining unit 203, and a code executing unit 204, where:
the request receiving unit 201 receives a service request carrying a request parameter value sent by a request end.
The flow template determining unit 202 determines a target flow template corresponding to the request parameter value carried in the data request and including at least one flow object according to a flow template file, where the flow template file includes a predetermined correspondence between the flow template and the request parameter value.
The code obtaining unit 203 obtains and loads service codes corresponding to each flow object in the target flow template from a code component container, where the code component container stores pre-extracted universal code components and personalized code components, and the codes in the code component container are updated in a dynamic deployment manner.
The code executing unit 204 executes the service codes sequentially according to the sequence of the flow objects in the target flow template, and obtains an execution result and returns the execution result to the request end.
In an alternative embodiment, the code component container includes a static component container storing generic code components and a dynamic component container storing personalized code components.
The code obtaining unit 203 may specifically include:
a determining subunit, configured to determine, according to each flow object included in the target flow template, a universal code component and a personalized code component required for implementing the target flow template;
a first obtaining subunit, configured to obtain the generic code component from the static component container;
and the second acquisition subunit acquires the personalized code component from the dynamic component container.
In an alternative embodiment, the code in the dynamic component container may be updated by dynamic deployment.
In an alternative embodiment, the apparatus further comprises:
and the code transfer unit is used for transferring the target code from the dynamic component container to the static component container when the target code in the dynamic component container is multiplexed by at least two business scenes.
In an alternative embodiment, the apparatus further comprises:
and the instantiation unit instantiates each flow object contained in the target flow template.
In an alternative embodiment, the generic code component is packed JAVA code and the personalized code component is JAVA class, and/or dynamic script, and/or EL expression, which need to be dynamically loaded.
The steps implemented when the above computer program is executed by the processor may refer to the description of the method embodiment above, and, on the premise of no conflict, the content of the apparatus embodiment above and the content of the method embodiment above may be complementary, which will not be described in detail.
The system, apparatus, module or unit set forth in the above embodiments may be implemented in particular by a computer chip or entity, or by a product having a certain function. A typical implementation device is a computer, which may be in the form of a personal computer, laptop computer, cellular telephone, camera phone, smart phone, personal digital assistant, media player, navigation device, email device, game console, tablet computer, wearable device, or a combination of any of these devices.
For convenience of description, the above devices are described as being functionally divided into various units, respectively. Of course, the functions of each element may be implemented in one or more software and/or hardware elements when implemented in the present application.
It will be appreciated by those skilled in the art that embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
In one typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.
The memory may include volatile memory in a computer-readable medium, random Access Memory (RAM) and/or nonvolatile memory, etc., such as Read Only Memory (ROM) or flash memory (flashRAM). Memory is an example of computer-readable media.
Computer readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of storage media for a computer include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices, or any other non-transmission medium, which can be used to store information that can be accessed by a computing device. Computer-readable media, as defined herein, does not include transitory computer-readable media (transshipment) such as modulated data signals and carrier waves.
It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article or apparatus that comprises the element.
It will be appreciated by those skilled in the art that embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The application may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The application may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.
In this specification, each embodiment is described in a progressive manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for system embodiments, since they are substantially similar to method embodiments, the description is relatively simple, as relevant to see a section of the description of method embodiments.
The foregoing is merely exemplary of the present application and is not intended to limit the present application. Various modifications and changes may be made to the present application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc. which are within the spirit and principles of the present application are intended to be included within the scope of the claims of the present application.
Claims (11)
1. A service request processing method, comprising:
the method comprises the steps that a flow engine receives a service request carrying a request parameter value sent by a request end;
the flow engine determines a target flow template which comprises at least one flow object and corresponds to a request parameter value carried in the service request according to a flow template file, wherein the flow template file comprises a predetermined corresponding relation between the flow template and the request parameter value;
the process engine acquires and loads service codes corresponding to each process object in the target process template from a code component container, wherein the code component container stores pre-extracted universal code components and personalized code components, and codes in the code component container are updated in a dynamic deployment mode;
the code component container comprises a static component container storing universal code components and a dynamic component container storing personalized code components; the process engine obtaining business codes corresponding to the process objects in the target process template from a code component container comprises:
the flow engine determines a universal code component and a personalized code component required by realizing the target flow template according to each flow object contained in the target flow template;
a flow engine acquires the universal code component from the static component container;
a flow engine acquires the personalized code component from the dynamic component container;
and the flow engine sequentially executes the service codes according to the sequence of the flow objects in the target flow template, obtains an execution result and returns the execution result to the request end.
2. The method of claim 1, wherein the code in the dynamic component container is updated by dynamic deployment.
3. The method of claim 1, the method further comprising:
when the object code in the dynamic component container is multiplexed by at least two business scenarios, the object code is transferred from the dynamic component container into the static component container.
4. The method of claim 1, after determining the target flow template, prior to retrieving the business code from the code component container, the method further comprising:
the process engine instantiates each process object contained in the target process template.
5. The method according to claim 1, the generic code component being packed JAVA code, the personalized code component being JAVA classes, and/or dynamic scripts, and/or EL expressions, which require dynamic loading.
6. A business request processing device is applied to a flow engine, and comprises a request receiving unit, a flow template determining unit, a code obtaining unit and a code executing unit, wherein:
the request receiving unit receives a service request carrying a request parameter value sent by a request end;
the flow template determining unit determines a target flow template which comprises at least one flow object and corresponds to a request parameter value carried in the service request according to a flow template file, wherein the flow template file comprises a corresponding relation between a predetermined flow template and the request parameter value;
the code acquisition unit acquires and loads service codes corresponding to all flow objects in the target flow template from a code component container, wherein the code component container stores pre-extracted universal code components and personalized code components, and codes in the code component container are updated in a dynamic deployment mode;
the code component container comprises a static component container storing universal code components and a dynamic component container storing personalized code components; the code acquisition unit includes:
a determining subunit, configured to determine, according to each flow object included in the target flow template, a universal code component and a personalized code component required for implementing the target flow template;
a first obtaining subunit, configured to obtain the generic code component from the static component container;
a second obtaining subunit, configured to obtain the personalized code component from the dynamic component container;
and the code executing unit sequentially executes the service codes according to the sequence of the flow objects in the target flow template, obtains an executing result and returns the executing result to the request end.
7. The apparatus of claim 6, the code in the dynamic component container is updated by dynamic deployment.
8. The apparatus of claim 6, the apparatus further comprising:
and the code transfer unit is used for transferring the target code from the dynamic component container to the static component container when the target code in the dynamic component container is multiplexed by at least two business scenes.
9. The apparatus of claim 6, the apparatus further comprising:
and the instantiation unit instantiates each flow object contained in the target flow template.
10. The apparatus of claim 6, the generic code component being packed JAVA code, the personalized code component being JAVA classes, and/or dynamic scripts, and/or EL expressions that require dynamic loading.
11. A business request processing system comprises a flow engine, a code update server, a static component container and a dynamic component container;
the static component container stores universal code components, and the dynamic component container stores personalized code components;
the code updating server is used for updating codes in the dynamic component container in a dynamic deployment mode;
the flow engine comprises a request receiving unit, a flow template determining unit, a code obtaining unit and a code executing unit, wherein:
the request receiving unit receives a service request carrying a request parameter value sent by a request end;
the flow template determining unit determines a target flow template which comprises at least one flow object and corresponds to a request parameter value carried in the service request according to a flow template file, wherein the flow template file comprises a corresponding relation between a predetermined flow template and the request parameter value;
the code acquisition unit acquires service codes corresponding to each flow object in the target flow template from a static component container and a dynamic component container and loads the service codes;
wherein the code acquisition unit includes:
a determining subunit, configured to determine, according to each flow object included in the target flow template, a universal code component and a personalized code component required for implementing the target flow template;
a first obtaining subunit, configured to obtain the generic code component from the static component container;
a second obtaining subunit, configured to obtain the personalized code component from the dynamic component container;
and the code executing unit sequentially executes the service codes according to the sequence of the flow objects in the target flow template, obtains an executing result and returns the executing result to the request end.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710367400.XA CN108958796B (en) | 2017-05-23 | 2017-05-23 | Service request processing method and device and service request processing system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710367400.XA CN108958796B (en) | 2017-05-23 | 2017-05-23 | Service request processing method and device and service request processing system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN108958796A CN108958796A (en) | 2018-12-07 |
| CN108958796B true CN108958796B (en) | 2023-08-04 |
Family
ID=64462477
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201710367400.XA Active CN108958796B (en) | 2017-05-23 | 2017-05-23 | Service request processing method and device and service request processing system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN108958796B (en) |
Families Citing this family (28)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109840111B (en) * | 2019-02-26 | 2022-03-22 | 广州衡昊数据科技有限公司 | Graphical service processing system and method |
| CN109933315A (en) * | 2019-02-26 | 2019-06-25 | 广州衡昊数据科技有限公司 | A kind of patterned transaction processing system and method |
| CN111614604B (en) * | 2019-02-26 | 2022-06-14 | 阿里巴巴集团控股有限公司 | Code file generation method and device |
| CN110069321A (en) * | 2019-03-16 | 2019-07-30 | 平安城市建设科技(深圳)有限公司 | Business containerization operation method, equipment, storage medium and device |
| CN111861047A (en) * | 2019-04-08 | 2020-10-30 | 阿里巴巴集团控股有限公司 | Data processing control method and computing device |
| CN110244990A (en) * | 2019-04-29 | 2019-09-17 | 五八有限公司 | Application component call method, device, electronic equipment and storage medium |
| CN110221824B (en) * | 2019-06-03 | 2024-03-22 | 北京秒针人工智能科技有限公司 | Method and device for generating component |
| CN110413286B (en) * | 2019-07-31 | 2023-08-22 | 创新先进技术有限公司 | Application deployment method, device and equipment |
| CN112445607B (en) * | 2019-09-03 | 2024-03-08 | 腾讯科技（深圳）有限公司 | Method and device for executing method function by application program |
| CN110688111A (en) * | 2019-09-25 | 2020-01-14 | 深圳乐信软件技术有限公司 | Configuration method, device, server and storage medium of business process |
| CN111104779B (en) * | 2019-11-13 | 2023-09-29 | 泰康保险集团股份有限公司 | Method, device, medium and electronic equipment for processing claim settlement business |
| CN112860268B (en) * | 2019-11-27 | 2024-04-05 | 北京沃东天骏信息技术有限公司 | Method and device for hot deployment of templates |
| CN113032374A (en) * | 2019-12-24 | 2021-06-25 | 北京数聚鑫云信息技术有限公司 | Data processing method, device, medium and equipment |
| CN111352626A (en) * | 2020-02-04 | 2020-06-30 | 北京三快在线科技有限公司 | Service request processing method and device, electronic equipment and storage medium |
| CN111427701A (en) * | 2020-03-09 | 2020-07-17 | 中国建设银行股份有限公司 | Workflow engine system and business processing method |
| CN111538484A (en) * | 2020-03-26 | 2020-08-14 | 北京迈格威科技有限公司 | Multi-project modular management method, biological unlocking model acquisition method and product |
| CN112099768B (en) * | 2020-08-04 | 2024-02-23 | 北京奇艺世纪科技有限公司 | Business process processing method and device and computer readable storage medium |
| CN111984623B (en) * | 2020-08-14 | 2024-02-09 | 北京人大金仓信息技术股份有限公司 | Automatic deployment method and device for database cluster, medium and electronic equipment |
| CN112099882B (en) * | 2020-09-11 | 2023-08-25 | 杭州海康威视数字技术股份有限公司 | Service processing method, device and equipment |
| CN112346818A (en) * | 2020-11-02 | 2021-02-09 | 北京新媒传信科技有限公司 | Container application deployment method and device, electronic equipment and storage medium |
| CN112650911A (en) * | 2020-12-17 | 2021-04-13 | 平安普惠企业管理有限公司 | Service message issuing method, device, computer equipment and storage medium |
| CN112631565A (en) * | 2020-12-25 | 2021-04-09 | 深圳云之家网络有限公司 | Service fusion method and device, computer equipment and storage medium |
| CN112612632B (en) * | 2020-12-31 | 2024-03-19 | 平安银行股份有限公司 | Message pushing method, system, computer equipment and storage medium based on stream |
| CN115134231B (en) * | 2021-03-17 | 2024-03-08 | 北京搜狗科技发展有限公司 | Communication method, device and device for communication |
| CN112951397A (en) * | 2021-03-29 | 2021-06-11 | 深圳市科曼医疗设备有限公司 | Perioperative period process management system and method |
| CN113254043A (en) * | 2021-06-04 | 2021-08-13 | 京东科技控股股份有限公司 | Web front-end project processing method and device, electronic equipment and storage medium |
| CN113448588B (en) * | 2021-07-09 | 2024-04-16 | 天津狮拓信息技术有限公司 | Data security processing method and device, electronic equipment and storage medium |
| CN114443169A (en) * | 2022-01-28 | 2022-05-06 | 中国民生银行股份有限公司 | Method and device for realizing technical component platformization |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105159761A (en) * | 2008-06-06 | 2015-12-16 | 苹果公司 | Application programming interfaces for data parallel computing on multiple processors |
| CN105357059A (en) * | 2015-12-08 | 2016-02-24 | 中国建设银行股份有限公司 | Business event processing method and apparatus |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20090024986A1 (en) * | 2007-07-19 | 2009-01-22 | Microsoft Corporation | Runtime code modification |
-
2017
- 2017-05-23 CN CN201710367400.XA patent/CN108958796B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105159761A (en) * | 2008-06-06 | 2015-12-16 | 苹果公司 | Application programming interfaces for data parallel computing on multiple processors |
| CN105357059A (en) * | 2015-12-08 | 2016-02-24 | 中国建设银行股份有限公司 | Business event processing method and apparatus |
Non-Patent Citations (1)
| Title |
|---|
| 基于模式的业务构件代码生成方法;冯锦丹等;《电子学报》;20081215;全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN108958796A (en) | 2018-12-07 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108958796B (en) | Service request processing method and device and service request processing system | |
| CN107025559B (en) | Service processing method and device | |
| CN111666096B (en) | Hot updating method and device for target application, storage medium and electronic equipment | |
| CN106990960B (en) | Code deployment method and device | |
| US20240111549A1 (en) | Method and apparatus for constructing android running environment | |
| CN105577813A (en) | Update method and system for web hybrid application | |
| CN107463422A (en) | Code dispositions method and device, electronic equipment | |
| CN108733589A (en) | The implementation method and device of distributed transaction heat deployment | |
| US20120159515A1 (en) | Sharing object representations | |
| US9411618B2 (en) | Metadata-based class loading using a content repository | |
| CN112930530A (en) | Client application for network application execution | |
| CN109343970B (en) | Application program-based operation method and device, electronic equipment and computer medium | |
| CN112612489B (en) | Method and device for constructing upgrade package of software and electronic equipment | |
| CN114020444A (en) | Calling system and method for resource service application in enterprise digital middleboxes | |
| CN113448650A (en) | Live broadcast function plug-in loading method, device, equipment and storage medium | |
| CN110727482A (en) | Interface updating method and device | |
| CN112650521A (en) | Software development kit SDK (software development kit) hot repair method and device and electronic equipment | |
| CN110968333B (en) | Configuration information replacement method and device, machine-readable storage medium and processor | |
| CN114064594B (en) | Data processing method and device | |
| CN110874322B (en) | Test method and test server for application program | |
| CN113127430A (en) | Mirror image information processing method and device, computer readable medium and electronic equipment | |
| CN116382713A (en) | Method, system, device and storage medium for constructing application mirror image | |
| CN113867776A (en) | Method and device for publishing middle station application, electronic equipment and storage medium | |
| US20180341475A1 (en) | Just In Time Deployment with Package Managers | |
| CN114860202A (en) | Project operation method, device, server and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| TA01 | Transfer of patent application right | ||
| TA01 | Transfer of patent application right |
Effective date of registration: 20200924 Address after: Cayman Enterprise Centre, 27 Hospital Road, George Town, Grand Cayman Islands Applicant after: Advanced innovation technology Co.,Ltd. Address before: A four-storey 847 mailbox in Grand Cayman Capital Building, British Cayman Islands Applicant before: Alibaba Group Holding Ltd. Effective date of registration: 20200924 Address after: Cayman Enterprise Centre, 27 Hospital Road, George Town, Grand Cayman Islands Applicant after: Innovative advanced technology Co.,Ltd. Address before: Cayman Enterprise Centre, 27 Hospital Road, George Town, Grand Cayman Islands Applicant before: Advanced innovation technology Co.,Ltd. |
|
| GR01 | Patent grant | ||
| GR01 | Patent grant |