A method and device for processing resource release

Abstract

The present invention discloses a processing method and device for resource release, and relates to the field of computer technology. A specific implementation of the method includes selecting a rule component and an action component in response to a resource release instruction to pull corresponding configuration data from a cache cluster; calling an execution engine, assembling the configuration data based on the rule component and the action component through a finite state machine, generating task data and storing it in a task list; receiving a resource request, obtaining the parameter field of the resource request, and then querying the task list according to the parameter field, obtaining the corresponding task data and sending it, so that the client can update the resources of the launched application. Therefore, the implementation of the present invention can solve the problem that there is no complete set of general release management for resources within the existing application APP.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a method and device for processing resource release. Background Art

[0002] Currently, apps often require both hotfix functionality and dynamic functionality, requiring the development and maintenance of two sets of interface services with similar functionality. Alternatively, if app A already has hotfix functionality, but app B does not, app B will need to develop a new set of hotfix services. Furthermore, apps require a grayscale release verification against a resource file before a full release. Currently, this requires developing a set of interface services with specific filtering criteria based on specific needs.

[0003] In the process of implementing the present invention, the inventors discovered that the prior art has at least the following problems:

[0004] Similar resource publishing functions for the same app lead to repetitive development and high maintenance costs, as well as a lack of a standardized lifecycle model and unified specifications for resource publishing. Furthermore, the same basic functions cannot be directly reused or quickly responded to across different apps, and basic common functions cannot be consolidated, preventing modularization and componentization for unified management and use. Summary of the Invention

[0005] In view of this, an embodiment of the present invention provides a method and apparatus for processing resource release, which can solve the problem that there is currently no complete set of universal release management for resources within an application program APP.

[0006] To achieve the above-mentioned purpose, according to one aspect of an embodiment of the present invention, a method for processing resource release is provided, including selecting rule components and action components in response to resource release instructions to pull corresponding configuration data from a cache cluster; calling an execution engine, assembling the configuration data based on rule components and action components through a finite state machine, generating task data and storing it in a task list; receiving a resource request, obtaining the parameter field of the resource request, and then querying the task list according to the parameter field, obtaining the corresponding task data and sending it, so that the client can update the resources of the launched application.

[0007] Optionally, the configuration data is assembled based on the rule component and the action component through the finite state machine, including: constructing a finite state machine instance and loading the configuration data into the memory; executing the rule component and filtering the configuration data, and then loading the publishing service class based on the filtered configuration data to generate task data; loading the task data into the memory, executing the loading of the task service class, and then rendering the loaded task data through the action component.

[0008] Optionally, after loading the task data into memory, include:

[0009] The rule component is executed to filter the task data so as to load the task service class according to the filtered task data.

[0010] Optionally, after generating the task data, the following steps are included:

[0011] Using the event mechanism, task data is mapped to the task event abstract class and task event listener to execute the implementation class of the task event listener corresponding to the task event abstract class, and the state change and persistence operations of the task data are implemented in the task event listener.

[0012] Optionally, the loaded task data is rendered through an action component, including:

[0013] The action component is configured in the action set of the task and encapsulated as an action set interface; the action set interface is called through the interface implementation class DefaultAction of the execution unit of the task action logic to obtain the expression; the loaded task data is rendered according to the expression, and the rendered action result is stored in the action pool.

[0014] Optionally, before responding to the resource release instruction, the method includes:

[0015] Synchronously update the resource publishing configuration data corresponding to the application in the database, as well as the corresponding rule components and action components to the cache cluster.

[0016] Optionally, after obtaining the corresponding task data and sending it so that the client can update the resources of the launched application, it also includes: receiving a data processing request sent by calling the data service interface, identifying the service type of the data processing request, and then determining the target object to be processed, and executing the data processing request; sending the processing results after execution to the query center, and storing the processing results in the database through a scheduled task.

[0017] In addition, the present invention also provides a processing device for resource release, including an acquisition module for selecting rule components and action components in response to resource release instructions to pull corresponding configuration data from a cache cluster; calling an execution engine to assemble the configuration data based on rule components and action components through a finite state machine, generate task data and store it in a task list; a processing module for receiving a resource request, obtaining the parameter field of the resource request, and then querying the task list according to the parameter field, obtaining the corresponding task data and sending it, so that the client can update the resources of the started application.

[0018] One embodiment of the above invention has the following advantages or beneficial effects: the present invention can perform rule verification and action processing on the resources (APK, JS, ZIP, etc.) within any application APP according to the user's delivery configuration on the page, so as to meet the delivery integrated process of first conducting a small-scale grayscale security verification for the released resources and then conducting a full-scale delivery. In addition, it provides regular mainline delivery (grayscale release, full-scale release, AA release, latest stable version), and realizes the full life cycle management of grayscale release, forming a closed loop of resource initialization, grayscale, reporting, statistics, and full-scale delivery capabilities. In addition, it is deeply integrated with business scenarios and provides a general resource release process for various business scenarios (Android grayscale release, IOS grayscale release, hot fix, dynamicization, etc.), which is ready to use without repeated development. In addition, it continuously precipitates and enriches the rule component library, providing rule components that support various dimensions (system version, APP version, city, population portrait, black and white list, installation volume, etc.), and the rule components can be arbitrarily arranged and combined.

[0019] The further effects of the above-mentioned non-conventional optional manner will be described below in conjunction with specific embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] The accompanying drawings are provided for a better understanding of the present invention and are not intended to limit the present invention.

[0021] Figure 1 is a schematic diagram of the main process of the resource publishing processing method according to the first embodiment of the present invention;

[0022] Figure 2 is a schematic diagram of an execution engine architecture according to an embodiment of the present invention;

[0023] Figure 3 is a timing diagram of the main process of responding to a resource release instruction according to an embodiment of the present invention;

[0024] Figure 4 is a schematic diagram of the main process of the resource publishing processing method according to the second embodiment of the present invention;

[0025] Figure 5 is a schematic diagram of the architecture of a method for processing resource release according to an embodiment of the present invention;

[0026] Figure 6 is a schematic diagram of main modules of a resource publishing processing device according to an embodiment of the present invention;

[0027] Figure 7 is an exemplary system architecture diagram in which embodiments of the present invention may be applied;

[0028] Figure 8 It is a schematic diagram of the structure of a computer system of a terminal device or a server suitable for implementing an embodiment of the present invention. DETAILED DESCRIPTION

[0029] The following description of exemplary embodiments of the present invention is made in conjunction with the accompanying drawings, in which various details of the embodiments of the present invention are included to facilitate understanding. These details should be considered as merely exemplary. Therefore, it should be appreciated by those skilled in the art that various changes and modifications may be made to the embodiments described herein without departing from the scope and spirit of the present invention. Similarly, for the sake of clarity and conciseness, descriptions of well-known functions and structures are omitted in the following description.

[0030] Figure 1 FIG. 1 is a schematic diagram of the main flow of the resource publishing processing method according to the first embodiment of the present invention. Figure 1 As shown, the resource publishing processing method includes:

[0031] Step S101 : In response to a resource publishing instruction, a rule component and an action component are selected to pull corresponding configuration data from a cache cluster.

[0032] In an embodiment, step S101, step S102, and step S103 can be executed in response to the resource release instruction of the application. Among them, the application is the largest unit in the system, and multiple types of resources can be associated with the application, and various types of releases and tasks can be created. Resource is the smallest unit for creating a task and selecting a release within the system. For example: APK, JS, ZIP file resources, etc. Release is the basic unit of the release type under the application, including a type of general business model that has been deposited in the system, such as dynamicization, hot fixes, App grayscale releases, etc.; and includes the ability to add and configure multiple rule components, which are globally effective for all tasks under this release.

[0033] In some embodiments, before executing step S101, the process includes: synchronously updating the resource publishing configuration data corresponding to the application in the database, as well as the corresponding rule components and action components to the cache cluster. For example, Figure 2The database DB shown includes persistent storage MySQL, cache cluster Redis and ElasticSearch database (ES database for short). The preset resource release configuration data and corresponding rule components and action components are all persistently stored in MySQL and can be synchronized to the cache cluster Redis.

[0034] Step S102 : calling the execution engine, assembling the configuration data based on the rule component and the action component through the finite state machine, generating task data and storing it in the task list.

[0035] In an embodiment, multiple rules can be added and configured under the rule Rule under the release and task, and the specification is componentized in the reuse scenario. For example, when configuring rules on the release and task configuration page, multiple rule components can be selected and sorted to determine the execution verification priority. The rules can be set as: short-circuit rules and non-short-circuit rules. Among them, the short-circuit rule is to directly return the rule verification failure information when the short-circuit rule fails to be executed, and the execution is cancelled. The non-short-circuit rule is to continue the execution of the next rule when the non-short-circuit rule fails to be executed; if there are multiple rule association relationship checks, the judgment intermediate information will be saved in the TaskContext context object of the Task.

[0036] In addition, the action is the execution unit of the task action logic, for example, calling third-party components, data encryption, result processing, etc.

[0037] In some embodiments, the configuration data is assembled based on the rule component and the action component through a finite state machine. The specific implementation process includes: constructing a finite state machine instance and loading the configuration data into the memory; executing the rule component and filtering the configuration data, and then loading the publishing service class based on the filtered configuration data to generate task data; loading the task data into the memory, executing the loading of the task service class, and then rendering the loaded task data through the action component. Furthermore, after the task data is loaded into the memory, the task data can be first filtered by rules and then the loading of the task service class can be executed. Specifically: executing the rule component and filtering the task data to load the task service class according to the filtered task data. Preferably, the present invention allocates resources to filter the configuration data through rules. It can be distinguished by writing an implementation class that inherits AbstractTaskRule to distinguish whether it is a short-circuit rule. The state judgment of the non-short-circuit rule logic can be saved as a temporary variable in the TaskContext (state context) in the task Task object to implement the logical judgment of the associated context data. Among them, Task is the smallest basic unit in the system. A task corresponds to a resource. Multiple rules and actions can be added. It can be divided into main tasks and subtasks according to type.

[0038] In addition, in a further embodiment, after the task data is generated, the task data can be processed by an event mechanism, and the specific implementation process includes: Figure 2 As shown, in the created finite state machine FSM, the event mechanism is used to map the task data TaskCode with the task event abstract class TaskEvent and the task event listener TaskListener, so as to execute the implementation class of the task event listener TaskListene corresponding to the task event abstract class TaskEvent, and implement the state change and persistence operation of the task data TaskCode in the task event listener TaskListene.

[0039] As a further embodiment, the loaded task data is rendered by the action component, and the specific implementation process includes: Figure 2 As shown, the action component is configured in the action set ActionMap of the task and encapsulated as an action set interface. The action set interface is called to obtain the expression through the interface implementation class DefaultAction of the execution unit Action of the task action logic. The loaded task data is rendered according to the expression, and the rendered action result is stored in the action pool Action Pool, that is, the execution unit Action interface implementation of the task action logic is inherited and maintained in the ActionPool. Preferably, the action set ActionMap stores the state code StateCode and the corresponding ActionInfo list, and SpEL (Spring Expression Language) can be used when calling the action set interface. That is, when the task Task is executed toNext, the expression expression of each ActionInfo in the ActionInfo list corresponding to the current task Task begins to be executed. Among them, the expression is the functional implementation class that implements the Action interface, and the ActionInfo object will be injected into the expression parsing engine before execution.

[0040] Regarding step S101 and step S102, a preferred embodiment is as follows: Figure 3 FIG. 1 is a timing diagram of a main process of responding to a resource release instruction according to an embodiment of the present invention, including:

[0041] In response to the resource release instruction of the application on the front-end page, it is passed to the finite state machine of the execution engine through the gateway service. The interface name exposed in the resource release instruction is obtained, and a finite state machine instance is constructed. According to the input parameters of the resource release instruction (i.e. the selected rule component and action component), the corresponding configuration data is pulled from the cache cluster, and then the configuration data is initialized to be loaded into the memory. Then, the configuration data is filtered by executing the rule verification under the release based on the rule component, and the rule verification result is returned. The filtered configuration data is loaded into the release service class to generate task data, where the tasks can be multiple and form a task set. The task data is filtered by executing the rule verification under the task based on the rule component, and the rule verification result is returned. The task service class is loaded according to the filtered task data, and the downstream interface of the action configuration (such as the action set interface) is called to render the loaded task data, and the rendered action result is passed to the front-end page through the gateway service.

[0042] It is worth noting that the rendered task data can be saved and will be in a pending release state after saving. The task status can be freely switched according to the resource task release situation (for example: pending release, grayscale release, full release, paused, offline, completed, etc.).

[0043] Step S103: receiving a resource request, obtaining a parameter field of the resource request, and then querying a task list according to the parameter field, obtaining corresponding task data and sending it, so that the client can perform resource update on the started application.

[0044] In some embodiments, after step S103, the process further includes: receiving a data processing request sent by calling a data service interface, identifying the service type of the data processing request (e.g., reporting service, query service), and then determining the target object to be processed, executing the data processing request; sending the processing result after execution to the query center, and storing the processing result in the database through a scheduled task. For example, Figure 2 As shown, the present invention provides a grayscale release interface, such as the grayscale release of APK installation packages, micro-application JS resources, hot fixes and other resources. The core adopts the finite state machine FSM, and can also provide data services such as data reporting service ReportService (such as point information reporting) and query service SearchService (such as installation volume query). Data Service can be encapsulated as a data service interface, and the reported and queried data are sent to the query center and stored in the database ElasticSearch through scheduled tasks.

[0045] Figure 4 FIG. 1 is a schematic diagram of the main flow of a method for processing resource release according to a second embodiment of the present invention. Figure 4As shown, the resource publishing processing method includes:

[0046] Step S401: Synchronously update the resource publishing configuration data corresponding to the application in the database, as well as the corresponding rule components and action components to the cache cluster.

[0047] Step S402 : In response to the resource publishing instruction, a rule component and an action component are selected to pull corresponding configuration data from the cache cluster.

[0048] Step S403: call the execution engine, build a finite state machine instance, and load the configuration data into the memory.

[0049] Step S404: executing the rule component to filter the configuration data, and then loading the publishing service class based on the filtered configuration data to generate task data.

[0050] Step S405 , loading the task data into the memory, executing the loading of the task service class, and then rendering the loaded task data through the action component.

[0051] Step S406: generating task data according to the rendered processing result and storing it in the task list.

[0052] Step S407: receiving a resource request, obtaining a parameter field of the resource request, and then querying a task list according to the parameter field, obtaining corresponding task data and sending it, so that the client can perform resource update on the started application.

[0053] Step S408: receiving a data processing request sent by calling a data service interface, identifying the service type of the data processing request, and then determining a target object to be processed, and executing the data processing request.

[0054] Step S409: Send the processed result to the query center and store it in the database through a scheduled task.

[0055] Figure 5 This is a schematic diagram of the architecture of a resource publishing method according to an embodiment of the present invention. This resource publishing method primarily involves the business layer's configuration management (Gaea), delivery service (Athena), data service (Hermes), MySQL service, Redis cluster service, and query center. Furthermore, the client can interact with the business layer for resource publishing via a gateway service. The gateway service includes the Nginx proxy server. The data storage layer primarily relies on the MySQL database service and Redis cluster service.

[0056] Configuration Management (Gaea) provides user operations and configuration tasks, persists data to a MySQL database (for example, storing backend configuration information and user status records), and synchronizes the latest configuration data to a Redis cache cluster (for example, storing configuration data such as delivery data, user data, and metrics data). Application Management within Configuration Management (Gaea) provides centralized management of connected applications. Resource Management is used to create tasks, select and publish resources, and centrally manage and view published resources, such as APKs, JS files, and ZIP files. Release Management provides centralized management of resource release types and records. For example, a release represents a common business model established within the system: dynamic, hotfixes, and app phased releases. Task Management provides centralized management of tasks within a specific release type for an application. Each task corresponds to a resource and can be assigned multiple rules and actions. Tasks can be categorized into main tasks and subtasks based on their type. Rule Management provides centralized management and viewing of abstracted rule components, allowing for component reuse for different scenarios. For example, management is done in the form of a rule component market, such as targeted rules, crowd tags, frequency and quantity control, blacklists and whitelists, app versions, and installation volume comparison components; multiple rules can be added and configured under releases and tasks. Action management provides unified management and viewing of abstracted action components, allowing component reuse based on different scenarios, and multiple rules can be added and configured under releases and tasks. Among them, an action is an abstraction for a type of execution process. In addition, the data dashboard provides a centralized display of data running on the platform, for example, the total number of connected applications, number of releases, total number of tasks, total number of downloads and installations, etc.

[0057] The delivery service (Athena) provides an interface service that pulls configuration data from a Redis cache cluster (i.e., the cache center). After filtering the configuration data through the execution engine, the action component combines and processes the data, ultimately delivering the assembled data that meets the requirements. The specific process includes: First, initializing the release data: pulling the corresponding configuration data from the cache cluster based on the input parameters of the resource release instruction. Then, initializing the configuration data and loading it into memory. Next, executing the release rules: filtering the configuration data based on the rule component through rule validation under the release execution. Then, loading the release service class: loading the filtered configuration data into the release service class to generate task data. Tasks can be multiple and form a task collection. Loading the task collection: executing the corresponding feature task service class and the corresponding task collection. Executing the task rules: filtering the task data based on the rule component through rule validation under the task execution. Executing the action: loading the task service class based on the filtered task data, calling the downstream interface of the action configuration to render the loaded task data. Return value processing: outputting the rendered action results in a unified manner.

[0058] In addition, the delivery service (Athena) can also provide security authentication (for example, security verification of resource release instructions) and measurement statistics (for example, measurement and statistics of data during the resource release process).

[0059] The data service (Hermes) can provide interface services, mainly responsible for reporting and collecting data to the query center, synchronizing the data in the Redis cache cluster, and then persisting the data in the MySQL database through scheduled tasks.

[0060] Figure 6 FIG. 1 is a schematic diagram of the main modules of the resource publishing processing device according to an embodiment of the present invention. Figure 6 As shown, the resource publishing processing device 600 includes an acquisition module 601 and a processing module 602. The acquisition module 601 selects a rule component and an action component in response to a resource publishing instruction to pull corresponding configuration data from the cache cluster; calls the execution engine to assemble the configuration data based on the rule component and the action component through a finite state machine, generates task data, and stores it in a task list; the processing module 602 receives a resource request, obtains the parameter field of the resource request, and then queries the task list based on the parameter field, obtains the corresponding task data, and sends it, so that the client can update the resources of the launched application.

[0061] In some embodiments, the acquisition module 601 assembles the configuration data based on the rule component and the action component through a finite state machine, including:

[0062] Build a finite state machine instance and load the configuration data into memory;

[0063] Execute the rule component to filter the configuration data, and then load the publishing service class based on the filtered configuration data to generate task data;

[0064] Load the task data into memory, execute the loading of the task service class, and then render the loaded task data through the action component.

[0065] In some embodiments, after the acquisition module 601 loads the task data into the memory, it includes: executing a rule component to filter the task data, so as to load the task service class according to the filtered task data.

[0066] In some embodiments, after the acquisition module 601 generates the task data, it includes:

[0067] Using the event mechanism, task data is mapped to the task event abstract class and task event listener to execute the implementation class of the task event listener corresponding to the task event abstract class, and the state change and persistence operations of the task data are implemented in the task event listener.

[0068] In some embodiments, the acquisition module 601 renders the loaded task data through the action component, including:

[0069] Configure the action component in the task's action set and encapsulate it as an action set interface;

[0070] Implement the DefaultAction class through the interface of the execution unit of the task action logic, call the action collection interface, and obtain the expression;

[0071] The loaded task data is rendered according to the expression, and the rendered action results are stored in the action pool.

[0072] In some embodiments, before the acquisition module 601 responds to the resource release instruction, it includes: synchronously updating the resource release configuration data corresponding to the application in the database, as well as the corresponding rule components and action components to the cache cluster.

[0073] In some embodiments, after the processing module 602 obtains and sends the corresponding task data so that the client updates the resources of the launched application, the process further includes:

[0074] Receive the data processing request sent by calling the data service interface, identify the service type of the data processing request, and then determine the target object to be processed, and execute the data processing request; send the processing results after execution to the query center, and store the processing results in the database through a scheduled task.

[0075] It should be noted that the resource publishing processing method and the resource publishing processing device of the present invention have corresponding relationships in terms of specific implementation contents, so the repeated contents will not be described again.

[0076] Figure 7 An exemplary system architecture 700 is shown to which the resource publishing processing method or resource publishing processing apparatus according to the embodiment of the present invention may be applied.

[0077] like Figure 7 As shown, system architecture 700 may include terminal devices 701, 702, 703, a network 704, and a server 705. Network 704 is used to provide a medium for communication links between terminal devices 701, 702, 703 and server 705. Network 704 may include various connection types, such as wired or wireless communication links or fiber optic cables.

[0078] Users can use terminal devices 701, 702, 703 to interact with server 705 via network 704 to receive or send messages, etc. Various communication client applications can be installed on terminal devices 701, 702, 703.

[0079] The terminal devices 701 , 702 , and 703 may be various electronic devices that have a processing screen for resource publishing and support web browsing, including but not limited to smart phones, tablet computers, laptop computers, and desktop computers.

[0080] Server 705 may be a server that provides various services, such as a background management server (for example only) that provides support for users utilizing terminal devices 701, 702, and 703. The background management server may analyze and process received data such as product information query requests, and feed back processing results (for example, target push information, product information—for example only) to the terminal device.

[0081] It should be noted that the resource publishing processing method provided in the embodiment of the present invention is generally executed by the server 705 , and accordingly, the computing device is generally set in the server 705 .

[0082] It should be understood that Figure 7 The number of terminal devices, networks and servers in the embodiment is merely illustrative. Any number of terminal devices, networks and servers may be provided as required.

[0083] Reference below Figure 8 , which shows a schematic structural diagram of a computer system 800 of a terminal device suitable for implementing an embodiment of the present invention. Figure 8 The terminal device shown is only an example and should not bring any limitation to the functions and scope of use of the embodiments of the present invention.

[0084] like Figure 8 As shown, the computer system 800 includes a central processing unit (CPU) 801, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 802 or a program loaded from a storage unit 808 into a random access memory (RAM) 803. Various programs and data required for the operation of the computer system 800 are also stored in the RAM 803. The CPU 801, ROM 802, and RAM 803 are connected to each other via a bus 804. An input / output (I / O) interface 805 is also connected to the bus 804.

[0085] The following components are connected to the I / O interface 805: an input section 806 including a keyboard, a mouse, and the like; an output section 807 including a cathode ray tube (CRT), a liquid crystal display (LCD), and a speaker; a storage section 808 including a hard disk; and a communication section 809 including a network interface card such as a LAN card or a modem. The communication section 809 performs communication processing via a network such as the Internet. A drive 810 is also connected to the I / O interface 805 as needed. A removable medium 811, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, and the like, is installed in the drive 810 as needed, so that a computer program read therefrom can be installed into the storage section 808 as needed.

[0086] In particular, according to the embodiments disclosed in the present invention, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, the embodiments disclosed in the present invention include a computer program product comprising a computer program carried on a computer-readable medium, the computer program comprising program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from a network via the communication section 809, and / or installed from a removable medium 811. When the computer program is executed by the central processing unit (CPU) 801, the above-mentioned functions defined in the system of the present invention are performed.

[0087] It should be noted that the computer-readable medium described in the present invention can be a computer-readable signal medium or a computer-readable storage medium, or any combination thereof. A computer-readable storage medium can be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of computer-readable storage media can include, but are not limited to, an electrical connection having one or more conductors, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination thereof. In the present invention, a computer-readable storage medium can be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In the present invention, a computer-readable signal medium can include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. This propagated data signal can take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium that can transmit, propagate, or transport a program for use by or in conjunction with an instruction execution system, apparatus, or device. Program code embodied on a computer-readable medium may be transmitted using any suitable medium, including but not limited to wireless, wireline, optical fiber cable, RF, or any suitable combination thereof.

[0088] The flowcharts and block diagrams in the accompanying drawings illustrate the possible implementation architecture, functions and operations of the systems, methods and computer program products according to various embodiments of the present invention. In this regard, each box in the flowchart or block diagram can represent a module, program segment, or a part of code, and the above-mentioned module, program segment, or a part of code contains one or more executable instructions for implementing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in an order different from that marked in the accompanying drawings. For example, two boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram or flowchart, and the combination of boxes in the block diagram or flowchart, can be implemented with a dedicated hardware-based system that performs the specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

[0089] The modules described in the embodiments of the present invention may be implemented in software or hardware. The modules described may also be provided in a processor. For example, a processor may be described as including an acquisition module and a processing module. The names of these modules do not, in some cases, limit the modules themselves.

[0090] As another aspect, the present invention also provides a computer-readable medium, which may be included in the device described in the above embodiment; or it may exist independently and not be assembled into the device. The above computer-readable medium carries one or more programs. When the above one or more programs are executed by a device, the device includes responding to a resource release instruction, selecting a rule component and an action component to pull corresponding configuration data from a cache cluster; calling an execution engine, assembling the configuration data based on the rule component and the action component through a finite state machine, generating task data and storing it in a task list; receiving a resource request, obtaining a parameter field of the resource request, and then querying the task list according to the parameter field, obtaining the corresponding task data and sending it, so that the client can update the resources of the started application.

[0091] The technical solution according to the embodiment of the present invention can solve the problem that there is currently no complete set of universal publishing management for resources in an application program APP.

[0092] The above specific embodiments do not limit the scope of protection of the present invention. Those skilled in the art will appreciate that various modifications, combinations, sub-combinations, and substitutions may occur depending on design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of the present invention are intended to be included within the scope of protection of the present invention.

Claims

1. A method for processing resource release, characterized in that: include: In response to the resource release instruction, select the rule component and the action component to pull the corresponding configuration data from the cache cluster; Calling the execution engine to assemble the configuration data based on the rule component and action component through the finite state machine, including: constructing a finite state machine instance and loading the configuration data into memory; executing the rule component to filter the configuration data, and then loading the publishing service class based on the filtered configuration data to generate task data and store it in the task list; loading the task data into memory, executing the loading of the task service class, and then rendering the loaded task data through the action component; Receive a resource request, obtain a parameter field of the resource request, and then query a task list according to the parameter field, obtain corresponding task data and send it, so that the client can update resources for the started application.

2. The method according to claim 1, characterized in that After loading the task data into memory, including: The rule component is executed to filter the task data so as to load the task service class according to the filtered task data.

3. The method according to claim 1, characterized in that After generating task data, including: Using the event mechanism, task data is mapped to the task event abstract class and task event listener to execute the implementation class of the task event listener corresponding to the task event abstract class, and the state change and persistence operations of the task data are implemented in the task event listener.

4. The method according to claim 1, wherein Render the loaded task data through the action component, including: Configure the action component in the task's action set and encapsulate it as an action set interface; Implement the DefaultAction class through the interface of the execution unit of the task action logic, call the action collection interface, and obtain the expression; The loaded task data is rendered according to the expression, and the rendered action results are stored in the action pool.

5. The method according to claim 1, wherein Before responding to a resource release instruction, include: Synchronously update the resource publishing configuration data corresponding to the application in the database, as well as the corresponding rule components and action components to the cache cluster.

6. The method according to any one of claims 1 to 5, characterized in that: After obtaining and sending the corresponding task data so that the client can update the resources of the launched application, it also includes: Receive a data processing request sent by calling a data service interface, identify the service type of the data processing request, determine the target object to be processed, and execute the data processing request; The processing results after execution are sent to the query center and stored in the database through scheduled tasks.

7. A resource publishing processing device, characterized in that: include: An acquisition module, configured to select a rule component and an action component in response to a resource release instruction to pull corresponding configuration data from the cache cluster; Calling the execution engine to assemble the configuration data based on the rule component and action component through the finite state machine, including: constructing a finite state machine instance and loading the configuration data into memory; executing the rule component to filter the configuration data, and then loading the publishing service class based on the filtered configuration data to generate task data and store it in the task list; loading the task data into memory, executing the loading of the task service class, and then rendering the loaded task data through the action component; The processing module is used to receive a resource request, obtain a parameter field of the resource request, and then query a task list according to the parameter field, obtain corresponding task data and send it, so that the client can update resources for the started application.

8. An electronic device, characterized in that: include: one or more processors; a storage device for storing one or more programs, When the one or more programs are executed by the one or more processors, the one or more processors implement the method according to any one of claims 1 to 6.

9. A computer-readable medium having a computer program stored thereon, characterized in that: When the program is executed by a processor, the method according to any one of claims 1 to 6 is implemented.

Images