Program package processing method, program package publishing method and related device

Abstract

The embodiment of the invention provides a program package processing method which is applied to an extension engine of a system platform. The method comprises the following steps: instantiating a received program package to obtain a program instance; putting the program instance into a dynamic instance pool; wherein the extension engine further comprises a static instance pool, the static instance pool comprises program instances, and the program instances in the static instance pool are generated through initialization when the system platform is started; under the condition that a calling request is received, the program instances in the dynamic instance pool are made to be prior to the program instances in the static instance pool, and the calling request is responded. Therefore, the publishing and deploying efficiency of the program package can be improved, and the speed and rhythm of updating and iteration of the system function are accelerated, so that the user requirements are met.

Description

Technical Field

[0001] The embodiments of the present application relate to the field of software development technology, and more particularly to a method for processing and publishing a program package and related devices. Background Art

[0002] Usually, the system's middle-office application can integrate multiple business parties to improve the efficiency of system function updates and iterations by integrating and sharing resources, such as providing standardized interfaces and software development tools, so as to quickly adapt to changes in user needs and optimize user experience.

[0003] In related technologies, when the system expands and updates its functions, the middle-end application usually needs to publish and deploy the program packages developed by the business parties in a fixed window period. For example, within the same window period, not only do the program packages developed by multiple business parties need to be tested and released together, but they may even need to be deployed by restarting the system, resulting in a long deployment time.

[0004] Therefore, there is a problem of low efficiency in publishing and deploying program packages in related technologies, which affects the update and iteration speed and rhythm of system functions. Summary of the invention

[0005] In view of this, multiple embodiments of the present application are dedicated to providing a method for processing and publishing a program package and related devices, which can improve the efficiency of publishing and deploying the program package to a certain extent.

[0006] One embodiment of the present application provides a method for processing a program package, which is applied to an extension engine of a system platform; the method comprises: instantiating a received program package to obtain a program instance; placing the program instance into a dynamic instance pool; wherein the extension engine further comprises a static instance pool, the static instance pool comprises program instances, and the program instances in the static instance pool are initialized and generated when the system platform is started; and when a call request is received, giving priority to the program instances in the dynamic instance pool over the program instances in the static instance pool to respond to the call request.

[0007] One embodiment of the present application provides a method for publishing a program package, the method comprising: sending the program package to the extension engine described in the aforementioned embodiment; wherein the program package comprises publishing information data and business logic data, and the business logic data is sent before the publishing information data; the business logic data comprises a class code for implementing the business logic, and the publishing information data comprises metadata for representing the functions implemented by the program package.

[0008] One embodiment of the present application provides an extension engine for a system platform, comprising: an instantiation module, used to instantiate a received program package to obtain a program instance; a storage module, used to put the program instance into a dynamic instance pool; wherein the extension engine also includes a static instance pool, the static instance pool includes program instances, and the program instances in the static instance pool are initialized and generated when the system platform is started; a response module, used to, when receiving a call request, give priority to the program instances in the dynamic instance pool over the program instances in the static instance pool and respond to the call request.

[0009] One embodiment of the present application also provides a publishing device for a program package, comprising: a sending module, used to send the program package to the extension engine described in the aforementioned embodiment; wherein the program package includes publishing information data and business logic data, and the business logic data is sent before the publishing information data; the business logic data includes class code for implementing business logic, and the publishing information data includes metadata for representing the functions implemented by the program package.

[0010] One embodiment of the present application provides a computer device, which includes a memory and a processor, wherein the memory stores at least one computer program, and the at least one computer program is loaded and executed by the processor to implement the aforementioned program package processing method.

[0011] One embodiment of the present application provides a computer-readable storage medium, wherein the computer-readable storage medium stores at least one computer program, and when the at least one computer program is executed by a processor, the processing method of the program package as described above can be implemented.

[0012] One embodiment of the present application provides a computer program product, which is used to implement the processing method of the program package as described above.

[0013] In multiple implementations provided in this application, the received program packages are instantiated and stored in a dynamic instance pool, while maintaining a static instance pool that is initialized and generated when the system platform is started, and the program instances in the dynamic instance pool are preferentially called when a call request is received, so that the system platform can dynamically load and update program packages without interrupting operation. In this way, the dynamic instance pool is used to manage program packages developed by multiple business parties, so that the system platform does not need to publish and deploy uniformly during the window period, which improves the efficiency of program package publishing and deployment, and thus speeds up the speed and rhythm of system function update iterations to meet user needs. BRIEF DESCRIPTION OF THE DRAWINGS

[0014] Figure 1A schematic diagram of system interaction for hot publishing of a program package provided for one embodiment of the present application.

[0015] Figure 2 A schematic diagram of the operation of a dynamic instance pool and a static instance pool is provided for one embodiment of the present application.

[0016] Figure 3 A schematic diagram of a method for processing a program package provided for one embodiment of the present application.

[0017] Figure 4 A schematic diagram of an expansion engine of a system platform provided for one embodiment of the present application.

[0018] Figure 5 A schematic diagram of a device for publishing a program package provided in accordance with one embodiment of the present application.

[0019] Figure 6 A schematic diagram of a computer device provided for one embodiment of the present application. DETAILED DESCRIPTION

[0020] The technical solutions in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, rather than all the embodiments.

[0021] In the description of the embodiments of the present application, it should be understood that the terms "first" and "second" are used for descriptive purposes only and cannot be understood as indicating or implying relative importance or implicitly indicating the number of technical features indicated. Thus, the features defined as "first" and "second" may explicitly or implicitly include one or more of the features. In the description of the embodiments of the present application, the meaning of "multiple" is two or more, unless otherwise clearly and specifically defined.

[0022] In related technologies, a middle-end application of a business system usually integrates multiple business parties. Based on the middle-end application, each business party can use the extension engine of the middle-end application of the system to carry out customized function development to meet differentiated needs. In turn, the functions of the middle-end application of the system can be continuously updated and iterated to meet the needs of various users and improve the user experience.

[0023] Before the functions customized by the business party are launched on the system's middle-office application, the program packages they develop need to be published and deployed on the system platform. However, in the related art, the release and deployment of the program packages developed by the business party depends on the release window of the system's middle-office application, and they need to be released uniformly within the window period, which affects the rhythm of function updates and iterations. In addition, the release mode of the system's middle-office application integration usually requires that program packages developed by multiple business parties be deployed uniformly after all tests have passed, resulting in a longer overall deployment time. Therefore, in the related art, the system's middle-office application has the problem of low efficiency in publishing and deploying program packages developed by its business parties.

[0024] Therefore, it is necessary to provide a method for processing program packages, which can improve the efficiency of program package release and deployment in the system middle-end application to a certain extent.

[0025] See also Figure 1 and Figure 2 . One embodiment of the present application provides an application scenario example of a method for processing a program package. The method for processing a program package can be applied to an extension engine of a system middle-end application of a system platform. The system platform may be an e-commerce platform system. The system middle-end application in this scenario example may be a shopping cart function middle-end application of an e-commerce platform system, which may provide multiple integrated function extension points. Different business parties may develop customized functions through the function extension points, and publish and deploy the developed program package through the extension engine of the shopping cart function middle-end application, thereby realizing the corresponding functions when the function extension points are executed.

[0026] In this scenario example, Platform A is a sub-platform under the e-commerce platform system that operates medical and health services. It currently needs to expand the shopping cart function and integrate a medication reminder function into the shopping cart for users to purchase pharmaceutical products, so as to help remind users to take medicine on time and in the right amount, thereby improving satisfaction. The developers of Platform A can develop software through the function extension points integrated in the shopping cart function middle-end application, and deploy the developed package B into the shopping cart function middle-end application.

[0027] In this scenario example, first, the developers of platform A can access the hot publishing platform for the developed package B. The hot publishing platform can be used to uniformly manage and publish the packages developed by the integrated business parties without interrupting the operation of the middle-end application. Specifically, for the accessed package, the hot publishing platform can have a publishing pipeline for processing its publishing tasks, including: permission verification, package data download, package data parsing, encapsulation of publishing data structure, publishing data push and other links. Therefore, by executing multiple links in the publishing pipeline in sequence, the package B data can be pushed to the extension engine of the shopping cart function middle-end application. Among them, the package B data can include a two-layer structure. The first layer is the publishing information data, which can include metadata for representing the functions implemented by the package, such as the published version information and the overview of the function extension point information. The second layer is the business logic data, which can include the class code for implementing the business logic, such as the class data of the function extension point implementation class. In order to improve the push efficiency, the hot publishing platform can use multi-threading to push the business logic data that are not dependent on each other, and push the publishing information data after all pushes are successful. It is triggered to take effect only when the publishing information data is pushed successfully.

[0028] The extension engine of the shopping cart function middle-end application can receive package B by listening to the package data push of the hot publishing platform, and can dynamically compile and instantiate the received package B, and then put the instantiated program instance B into the function extension point execution instance pool. When the shopping cart function middle-end application executes the business logic of the function extension point corresponding to package B, it can call the extension engine and route it to the corresponding program instance B in the function extension point execution instance pool through the stub code for execution response, so as to realize the medication reminder function in the shopping cart of users who purchase pharmaceutical products.

[0029] In this scenario example, refer to Figure 2 , the function extension point execution instance pool can include a static instance pool and a dynamic instance pool. Among them, the static instance pool is the instance pool that is put into after the static code is used to initialize the parsing, loading and instantiation when the shopping cart function middle platform application is started. The dynamic instance pool is the instance pool that is put into after the received package is dynamically parsed, loaded and instantiated by listening to the package data push of the hot publishing platform when the shopping cart function middle platform application is running, that is, without restarting the middle platform application. Therefore, after package B is received and instantiated by the extension engine, the corresponding program instance B can be placed in the dynamic instance pool.

[0030] In this scenario example, since the program instance B in the dynamic instance pool is the latest program instance developed by the developers of platform A to implement the medication reminder function in the shopping cart, when the extension engine is called to execute the function extension point, it can be preferentially routed to the dynamic instance pool to execute the program instance, so that the newly developed medication reminder function in the shopping cart can be implemented during execution. Similarly, the program instances corresponding to other newly developed functions in the dynamic instance pool can also be routed to the dynamic instance pool and executed separately when the extension engine is called to achieve the "hot update" of the shopping cart function middle-end application. In this way, there is no need to rely on the shopping cart function middle-end application to uniformly publish and deploy program packages, which improves the efficiency of program package publishing and deployment, has strong flexibility, and is less invasive to the original business logic.

[0031] In this scenario example, in order to minimize the update of program instances in the dynamic instance pool and shorten the dynamic instantiation time, when the extension engine monitors the data push of package B from the hot publishing platform, it will first perform idempotent control based on the unique number of the version of package B to avoid repeated instantiation. In addition, the extension engine has different instantiation strategies for the release version or snapshot version of package B. Specifically, for the release version of package B, if it is consistent with the static code version of the shopping cart function middle platform application, the extension engine will skip the instantiation of package B and directly use the static instance pool when it is called. For the snapshot version of package B, the extension engine can compare the md5 value of the class code in package B with the md5 value of the class code of the static code for each functional extension point to compare whether the implementation class code of each functional extension point has been changed. If the md5 value of the class code in package B is inconsistent with the md5 value of the class code of the static code, dynamic instantiation is triggered, and the compiled class data is instantiated using FastClass and placed in the dynamic instance pool. If the md5 value of the class code in package B is consistent with the md5 value of the class code of the static code, the static program instance corresponding to the class code in the static instance pool is placed in the dynamic instance pool for use. In this way, during the process of rolling updates of program instances in the dynamic instance pool by the extension engine, the updates and replacements of program instances in the dynamic instance pool can be minimized, saving computing resources.

[0032] See also Figure 3. The embodiment of the present application provides a method for processing a program package. The method for processing the program package can be applied to the extension engine of the system platform. The extension engine of the system platform can run in a server, and the server can be an electronic device with certain computing power and network access capabilities, which can have a network communication module, a processor, and a memory, etc. Of course, the server can also refer to software running in an electronic device. The server can also be a distributed server, which can be a system with multiple processors, memories, network communication modules, etc. operating in collaboration. Alternatively, the server can also be a server cluster formed by several servers. Alternatively, with the development of science and technology, the server can also be a new technical means that can realize the corresponding functions of the embodiment of the specification. For example, it can be a new form of "server" based on quantum computing.

[0033] In this embodiment, the system platform can be a business system platform or a middle-end application of a business system. Specifically, for example, the system platform can be an e-commerce platform or a middle-end application of a shopping cart function or a payment function of an e-commerce platform.

[0034] In this embodiment, the method for processing a program package may include the following steps.

[0035] Step S110: instantiate the received program package to obtain a program instance.

[0036] In this embodiment, the program package can be used as a code collection developed for the functional extension points of the system platform to realize the extended functions of the system platform application. The program package can improve the modularity, maintainability and reusability of the code, and help manage and distribute software components. Specifically, the program package may include various business logic modules, functional extension components or plug-ins. For example, the system platform may be a middle-end application for ordinary payment functions. If a third party implements the face recognition payment function on the system platform, its developers can customize the development through the functional extension points integrated in the system platform to obtain the corresponding program package.

[0037] In some implementations, the program package may be a two-party package, i.e., a software package developed or maintained by two major parties. Specifically, the two-party package cannot be deployed independently on the system platform, but requires the system platform and its integrated business parties as the main participants to embed it as a plug-in into the system platform for deployment.

[0038] In this embodiment, the instantiation process is used to convert an abstract class or template into a specific object when deploying a program package. Specifically, when the extension engine of the system platform receives the program package, the classes and components contained in the program package are in an uninstantiated form, that is, they are in a general and configurable state waiting for specific configuration and processing. Through the instantiation process, the uninstantiated abstract classes or components in the program package can be customized according to the specific deployment environment in the extension engine to generate a program instance specific to the extension engine.

[0039] In this embodiment, the program instance can be used as the basic unit for implementing the application function of the program package, and is used to convert the abstract class definition in the program package into an object with specific properties and status, so that the function extension point can be executed to respond when the extension engine is called. For example, the program package received by the extension engine can be the program package corresponding to the "one-click purchase" function developed by the business party for the shopping cart middle-end application, which contains the class code related to the business logic of implementing this function. After the extension engine instantiates and deploys it, it can create multiple corresponding program instances for different objects. For each user who visits the website, a corresponding program instance can be created based on the predefined class in the program package. When the shopping cart middle-end application needs to call the "one-click purchase" function, the created program instance can start a series of predefined operations, such as verifying inventory, checking payment information, and submitting orders to achieve a response.

[0040] In this embodiment, the extension engine of the system platform can instantiate the received program package through the steps of parsing and loading the program package, initializing the runtime context, creating specific objects, injecting dependencies, registering event listeners or callback functions, and finally starting and activating the instance, so as to convert the abstract definition in the program package into a program instance for specific execution.

[0041] Step S120: putting the program instance into the dynamic instance pool; wherein the extension engine also includes a static instance pool, the static instance pool includes the program instance, and the program instance in the static instance pool is initialized and generated when the system platform is started.

[0042] In this embodiment, the dynamic instance pool can be used as a container for dynamically managing program instances when the system platform application is running, and is used to store and manage program instances obtained by the extension engine of the system platform after dynamically loading and instantiating the program package. Unlike the static instance pool, the program instances in the static instance pool are loaded and remain unchanged when the system platform is started, while the dynamic instance pool supports dynamically updating and replacing existing program instances according to external trigger events, such as receiving a program package, during the operation of the system platform, so that the functions of the program package can be expanded or updated in real time without restarting the system platform. When the new program package is pushed to the extension engine of the system platform and is dynamically loaded and instantiated, the corresponding program instance will be added to the dynamic instance pool. If there is a call request related to its function, the extension engine will give priority to selecting the corresponding program instance from the dynamic instance pool to respond to achieve "hot update". For example, assuming that one of the business parties of the e-commerce platform needs to do customized development and update for the shopping cart function, its developers can package the new business logic into a program package and push it to the system platform. After the program package is loaded and instantiated by the extension engine of the system platform, the new program instance will be placed in the dynamic instance pool and called for execution according to specific business needs when the user uses the shopping cart function. If the function needs to be further updated later, the system platform only needs to place the program instance corresponding to the received updated program package into the dynamic instance pool to replace the original program instance without restarting the entire system platform. In this way, the dynamic instance pool can effectively improve the flexibility and scalability of the system platform and reduce the impact on the speed and rhythm of function update iterations.

[0043] Step S130: when a call request is received, the program instances in the dynamic instance pool are prioritized over the program instances in the static instance pool to respond to the call request.

[0044] In this embodiment, the call request may be a request for extended functionality initiated by an external or internal component during the operation of the system platform. Specifically, the call request may point to one or more functional extension points to trigger the execution of corresponding business logic. In this embodiment, the call request may originate from user operations, system events, other components of the system platform, or third-party service components. For example, a call request may be a request to the server to execute relevant preferential policies when a user clicks a purchase button on the client of an e-commerce platform. For another example, a call request may also be a request to execute functions related to inventory management or order processing when the system triggers a scheduled task.

[0045] In this embodiment, the call request will be sent to the extension engine of the system platform, and the extension engine can route it to the program instance in the dynamic instance pool or the static instance pool for response according to the functional requirements corresponding to the call request.

[0046] In this embodiment, the extension engine can preferentially select a program instance from the dynamic instance pool. If there is no matching program instance in the dynamic instance pool, it will be routed to the static instance pool to find the corresponding program instance for response. In this way, the extension engine can always keep executing the latest business logic to achieve "hot update". For example, the shopping cart function of the e-commerce platform introduces a program instance corresponding to a new discount calculation function in the dynamic instance pool when the middle-end application is running. When the user initiates a purchase request, the system platform can call the extension engine to execute the function extension point of the discount calculation function. The extension engine can first call the latest program instance of the discount calculation function from the dynamic instance pool so that the system platform can apply the latest promotion rules. If there is no program instance related to the discount calculation function in the dynamic instance pool, it will be routed to the static instance pool to find the program instance for execution.

[0047] In this embodiment, the received program packages are instantiated and stored in a dynamic instance pool, while a static instance pool is maintained that is initialized and generated when the system platform is started, and the program instances in the dynamic instance pool are preferentially called when a call request is received, so that the system platform can dynamically load and update program packages without interrupting operation. In this way, the dynamic instance pool is used to manage program packages developed by multiple business parties, so that the system platform does not need to publish and deploy them uniformly during the window period, which improves the efficiency of program package publishing and deployment, and thus speeds up the speed and rhythm of system application function update iterations to meet user needs.

[0048] Furthermore, in this embodiment, by setting up a dynamic instance pool and a static instance pool, after the system platform has been running for a period of time, the code version of the implementation class corresponding to each program instance in the dynamic instance pool will be higher than that in the static instance pool. This version inconsistency may cause inconsistency in the execution of certain functions of the system platform, or instability and errors when switching between different versions. At this time, the extension engine can also push the latest code version of each implementation class in the dynamic instance pool to the system platform for integrated release, align the code versions in the dynamic instance pool and the static instance pool, thereby reducing the risks and potential problems caused by version differences.

[0049] In some embodiments, the program package includes release information data and business logic data. The extension engine can receive the business logic data sent prior to the release information data, and parse and load the business logic data; wherein the business logic data includes class code for implementing the business logic; based on the received release information data, the business logic data is configured; wherein the release information data includes metadata for indicating the functions implemented by the program package.

[0050] In this embodiment, the release information data and the business logic data can be two-layer structure data in the program package. Among them, the release information data can include metadata related to the release of the program package, such as version information, function description, dependency, compatibility requirements and other information. The release information data can be used to provide the system platform with basic information about the program package to help the system platform identify, manage and process the program package. For example, the release information data can include the version number of the program package, indicating whether the current program package is a new version, or whether it is a repaired version of a certain function. For another example, the release information data can also include other module information on which the program package depends to ensure that the program package can run smoothly in a specific version of the system or other components.

[0051] Business logic data can be code data in a package used to execute specific business logic, class code or other code written by developers. Specifically, business logic data can define the core functions of the package and implement specific business operations and calculations. For example, in an e-commerce platform, business logic data may include code for processing shopping cart settlement, calculating discounts, inventory checking, and other functions. Business logic data is responsible for responding to requests initiated by the system or users and completing the core tasks that the system needs to perform.

[0052] In this embodiment, the business logic data may include class data of the implementation class of each functional extension point in the system platform. Specifically, the business logic data may be pushed to the extension engine by the hot publishing platform of the program package. In one package push, multiple business logic data may be issued, and the published information data may be only one. Since there is no data dependency between the multiple business logic data, multi-threading may be used to push the business logic data first. After all the business logic data are successfully pushed, the published information data is pushed to improve the push efficiency. Correspondingly, the extension engine may start to receive the published information data only after successfully receiving the business logic data. In the extension engine, the final triggering and effectiveness of the received program package depends on the published information data. The reception of the program package is completed only when the extension engine successfully receives the published information data.

[0053] In some embodiments, the program package has a version identifier. The extension engine can compare the hash value of the class code in the received program package with the hash value of the class code of the corresponding program instance in the static instance pool when the version identifier of the received program package indicates that the program package is a primary version; and instantiate the received program package to obtain a program instance when the hash value of the received program package is different from the hash value of the class code of the corresponding program instance in the static instance pool.

[0054] In this embodiment, the version identifier of the program package can be used to represent the version information of the program package. Specifically, the version identifier can not only help the extension engine of the system platform determine whether the received program package is the latest version, but also distinguish and manage multiple different versions. Through the version identifier, the extension engine can perform corresponding processing according to the version information of the program package. For example, the version identifier can be in the form of a number or a string.

[0055] In the present embodiment, when the version mark of the received program package is the primary version, that is, when the code version of the received program package is consistent with the initialization code version in the static instance pool, the extension engine can compare the class code in the received program package with the class code of the corresponding program instance in the static instance pool for the implementation class of each functional extension point, and further process according to the result of the comparison. Specifically, for example, the hash value of the class code in the received program package can be compared with the hash value of the class code of the corresponding program instance in the static instance pool. The hash value, as a unique identifier, can be used to identify a specific class code. The hash value can effectively prevent code duplication or unexpected changes. By comparing the hash value, the extension engine can accurately determine whether the received program package is consistent with the corresponding program instance in the current static instance pool. Of course, other unique identifiers can also be used as comparison criteria.

[0056] Specifically, when the hash value of the received package is different from the hash value of the class code of the corresponding program instance in the static instance pool, the extension engine can instantiate the received package. When the hash value of the received package is inconsistent with the hash value of the corresponding program instance in the static instance pool, it means that the class code in the package has changed relative to the current version, which may be a function repair or optimization. At this time, the extension engine loads it into the system, which can ensure that the system platform always maintains the latest version of the function.

[0057] In some implementations, the extension engine may place the corresponding program instance in the static instance pool into the dynamic instance pool when the hash value of the received program package is the same as the hash value of the class code of the corresponding program instance in the static instance pool.

[0058] In this embodiment, the static instance pool is a program instance pool preloaded and instantiated when the system starts, in which the program instances are usually generated by static code and involve basic functional modules required by the system when it is initialized. The program instances in the static instance pool contain the core, known and stable business logic of the system.

[0059] In this embodiment, when the hash value of the program package received by the extension engine is the same as the hash value of the class code of the corresponding program instance in the static instance pool, it means that the received program package is completely consistent with the program instance in the current static instance pool, and the class code has not changed. Therefore, the extension engine can directly put the program instance that already exists in the static instance pool into the dynamic instance pool, avoiding unnecessary repeated processing, keeping the update content to a minimum, improving the performance and response speed of the system, and reducing the waste of computing resources.

[0060] In some embodiments, the program package has a version identifier; the extension engine may compare the hash value of the class code in the received program package with the hash value of the class code of the corresponding program instance in the static instance pool when the version identifier of the received program package indicates that the program package is a released version; and abandon the received program package when the hash value of the received program package is the same as the hash value of the class code of the program instance in the static instance pool.

[0061] In some embodiments, a program package may have various version types, such as a test version, a pre-release version, a fix version, a snapshot version, or a release version. Unlike other types of versions, a release version may be a program package version that is fully tested, stable, and ready to be released to users. Specifically, the release version contains all the functions required by the system platform to ensure smooth operation when it goes online.

[0062] In some implementations, since the release version of the program package in the system platform does not allow the same version to be overwritten, if the code version of the program package is consistent with the code version corresponding to the program instance in the static instance pool, the release version of the program package needs to be abandoned and the code version corresponding to the program instance in the static instance pool is directly used. This code version update strategy also ensures that only program packages that have actually changed are processed when the system platform updates its functions, keeps the update content to a minimum, avoids unnecessary waste of computing resources, and improves the operating efficiency and response speed of the system platform.

[0063] The embodiment of the present application also provides a method for publishing a program package. The publishing method comprises: sending the program package to the extension engine described in the aforementioned embodiment; wherein the program package comprises publishing information data and business logic data, and the business logic data is sent before the publishing information data; the business logic data comprises a class code for implementing the business logic, and the publishing information data comprises metadata for indicating the functions implemented by the program package.

[0064] In this embodiment, the method for publishing a program package can be applied to a third party's hot publishing platform or a hot publishing platform integrated with a system platform. A hot publishing platform refers to a system platform for dynamically publishing, updating or deploying program packages without interrupting or minimizing system downtime. The main function of a hot publishing platform is to support real-time push, update and deployment of program packages without restarting the system or affecting the normal use of users. Such a platform usually has a flexible publishing mechanism, can handle different versions of program packages, perform version control, and ensure the stability and reliability of the publishing process. The hot publishing platform provides continuous support and iterative update capabilities for runtime applications by pushing the functions, repairs or enhancements of the new version to the running system platform in real time. The hot publishing platform can not only push program packages including business logic data, publishing information data, etc., but also ensure the compatibility and correctness of the program packages, and avoid the emergence of version conflicts and inconsistency problems.

[0065] In actual applications, for example, an e-commerce platform may use a hot publishing platform to dynamically update the functional modules of its payment system. The platform can push new payment interfaces written by developers or fixed payment vulnerabilities to the extension engine of the system platform through the hot publishing platform without restarting the platform or affecting the ongoing transactions of users. In this way, the hot publishing platform can significantly improve the flexibility and efficiency of the functional updates of the system platform.

[0066] In this embodiment, the hot publishing platform can directly send the program package data to the extension engine, or push it using middleware.

[0067] See also Figure 4 The embodiment of the present application also provides an extension engine of a system platform, which may specifically include the following modules.

[0068] An instantiation module, used to instantiate the received program package to obtain a program instance;

[0069] A storage module, used to put the program instance into a dynamic instance pool; wherein the extension engine also includes a static instance pool, the static instance pool includes program instances, and the program instances in the static instance pool are initialized and generated when the system platform is started;

[0070] The response module is used for, when receiving a call request, giving priority to the program instances in the dynamic instance pool over the program instances in the static instance pool to respond to the call request.

[0071] In this embodiment, the specific functions and effects achieved by the extension engine of the system platform can be explained with reference to other embodiments of the present application and will not be repeated here.

[0072] See also Figure 5 The embodiment of the present application also provides a publishing device for a program package, which may specifically include the following modules.

[0073] A sending module is used to send a program package to the extension engine described in the aforementioned implementation mode; wherein the program package includes release information data and business logic data, and the business logic data is sent before the release information data; the business logic data includes a class code for implementing the business logic, and the release information data includes metadata for indicating the functions implemented by the program package.

[0074] In this embodiment, the specific functions and effects achieved by the publishing device of the program package can be explained with reference to other embodiments of the present application and will not be repeated here.

[0075] The embodiment of the present application further provides a computer-readable storage medium on which a computer program is stored. When the computer program is executed by a processor, the processor implements the processing method of the program package as described above.

[0076] The embodiment of the present application also provides a computer program product including instructions, and when the computer program product is executed by a processor, the processing method of the program package as described above is implemented.

[0077] See also Figure 6 The present embodiment may provide a computer device, the computer device comprising: a memory, and one or more processors communicatively connected to the memory; the memory stores instructions executable by the one or more processors, the instructions are executed by the one or more processors, so that the one or more processors implement the aforementioned program package processing method.

[0078] In some embodiments, the computer device may include a processor, a non-volatile storage medium, an internal memory, a communication interface, a display device, and an input device connected by a system bus. The non-volatile storage medium may store an operating system and related computer programs.

[0079] The user information or user account information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, etc.) involved in multiple implementation methods of the present application are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of relevant data must comply with the relevant laws and standards of relevant countries and regions, and provide corresponding operation entrances for users to choose to authorize or refuse.

[0080] It should be understood that the specific examples in this article are only intended to help those skilled in the art to better understand the embodiments of the present application, rather than to limit the scope of the present invention.

[0081] It can be understood that in the various implementations of the present application, the size of the serial number of each process does not mean the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the implementation methods of the present application.

[0082] It can be understood that the various embodiments described in this application can be implemented individually or in combination, and the embodiments of this application are not limited to this.

[0083] Unless otherwise stated, all technical and scientific terms used in the embodiments of the present application have the same meaning as those generally understood by those skilled in the art of the technical field of the present application. The terms used in the present application are only for the purpose of describing specific embodiments and are not intended to limit the scope of the present application. The term "and / or" used in the present application includes any and all combinations of one or more related listed items. The singular forms of "a kind of", "above" and "the" used in the embodiments of the present application and the appended claims are also intended to include plural forms, unless the context clearly indicates other meanings.

[0084] It can be understood that the processor of the embodiment of the present application can be an integrated circuit chip with signal processing capabilities. In the implementation process, each step of the above method implementation can be completed by the hardware integrated logic circuit or software instructions in the processor. The above processor can be a general processor, a digital signal processor (DigitalSignal Processor, DSP), an application-specific integrated circuit (Application Specific Integrated Circuit, ASIC), a field programmable gate array (Field Programmable Gate Array, FPGA) or other programmable logic devices, discrete gates or transistor logic devices, discrete hardware components. The methods, steps and logic block diagrams disclosed in the embodiment of the present application can be implemented or executed. The general processor can be a microprocessor or the processor can also be any conventional processor, etc. The steps of the method disclosed in the embodiment of the present application can be directly embodied as a hardware decoding processor to perform, or the hardware and software modules in the decoding processor are combined and executed. The software module can be located in a mature storage medium in the field such as a random access memory, a flash memory, a read-only memory, a programmable read-only memory or an electrically erasable programmable memory, a register, etc. The storage medium is located in the memory, and the processor reads the information in the memory and completes the steps of the above method in combination with its hardware.

[0085] It is understood that the memory in the embodiments of the present application may be a volatile memory or a non-volatile memory, or may include both volatile and non-volatile memory. Among them, the non-volatile memory may be a read-only memory (ROM), a programmable read-only memory (programmable ROM, PROM), an erasable programmable read-only memory (erasable PROM, EPROM), an electrically erasable programmable read-only memory (EEPROM) or a flash memory. The volatile memory may be a random access memory (RAM). It should be noted that the memory of the systems and methods described herein is intended to include, but is not limited to, these and any other suitable types of memory.

[0086] Those of ordinary skill in the art will appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of this application.

[0087] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can refer to the corresponding processes in the aforementioned method implementation methods and will not be repeated here.

[0088] In the several embodiments provided in the present application, it should be understood that the disclosed systems, devices and methods can be implemented in other ways. For example, the device implementation described above is only schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0089] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the present embodiment.

[0090] In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

[0091] If the function is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application can be essentially or partly embodied in the form of a software product that contributes to the prior art, and the computer software product is stored in a storage medium, including a number of instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present application. The aforementioned storage medium includes: various media that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0092] The above is only a specific implementation of the present application, but the protection scope of the present invention is not limited thereto. Any person skilled in the art who is familiar with the present technical field can easily think of changes or substitutions within the technical scope disclosed in the present application, which should be included in the protection scope of the present application. Therefore, the protection scope of the present invention should be based on the protection scope of the claims.

Claims

1. A method for processing a program package, characterized in that: An extension engine applied to a system platform; the method comprises: Instantiate the received program package to obtain a program instance; Putting the program instance into a dynamic instance pool; wherein the extension engine further includes a static instance pool, the static instance pool includes program instances, and the program instances in the static instance pool are initialized and generated when the system platform is started; When a call request is received, the program instances in the dynamic instance pool are prioritized over the program instances in the static instance pool to respond to the call request.

2. The method according to claim 1, characterized in that The program package includes publishing information data and business logic data; the method also includes: Receiving business logic data issued prior to the published information data, and parsing and loading the business logic data; wherein the business logic data includes class codes for implementing the business logic; The business logic data is configured based on the received publishing information data; wherein the publishing information data includes metadata for representing the functions implemented by the program package.

3. The method according to claim 2, characterized in that The method further comprises: After successfully receiving the business logic data, the publishing information data is received.

4. The method according to claim 1, characterized in that: The program package has a version identifier; The step of instantiating the received program package to obtain a program instance includes: When the version identifier of the received program package indicates that the program package is a primary version, comparing the hash value of the class code in the received program package with the hash value of the class code of the corresponding program instance in the static instance pool; When the hash value of the class code in the received program package is different from the hash value of the class code of the corresponding program instance in the static instance pool, the received program package is instantiated to obtain the program instance.

5. The method according to claim 4, characterized in that The method further comprises: When the hash value of the class code in the received program package is the same as the hash value of the class code of the corresponding program instance in the static instance pool, the corresponding program instance in the static instance pool is put into the dynamic instance pool.

6. The method according to claim 1, characterized in that The program package has a version identifier; The method further comprises: When the version identifier of the received program package indicates that the program package is a released version, comparing the hash value of the class code in the received program package with the hash value of the class code of the corresponding program instance in the static instance pool; When the hash value of the class code in the received program package is the same as the hash value of the class code of the corresponding program instance in the static instance pool, the received program package is discarded.

7. A method for publishing a program package, characterized in that: The method comprises: sending a program package to the expansion engine described in claim 1; The program package includes release information data and business logic data, and the business logic data is issued before the release information data; the business logic data includes class code for implementing business logic, and the release information data includes metadata for representing the functions implemented by the program package.

8. An extension engine for a system platform, characterized in that: include: An instantiation module, used to instantiate the received program package to obtain a program instance; A storage module, used to put the program instance into a dynamic instance pool; wherein the extension engine also includes a static instance pool, the static instance pool includes program instances, and the program instances in the static instance pool are initialized and generated when the system platform is started; The response module is used for, when receiving a call request, giving priority to the program instances in the dynamic instance pool over the program instances in the static instance pool to respond to the call request.

9. A device for publishing a program package, characterized in that: include: A sending module, used for sending the program package to the extension engine described in claim 1; The program package includes release information data and business logic data, and the business logic data is issued before the release information data; the business logic data includes class code for implementing business logic, and the release information data includes metadata for representing the functions implemented by the program package.

10. A computer device, characterized in that: The computer device includes a memory and a processor, wherein at least one computer program is stored in the memory, and the at least one computer program is loaded and executed by the processor to implement the method according to any one of claims 1 to 7.

11. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores at least one computer program, and when the at least one computer program is executed by a processor, the method according to any one of claims 1 to 7 can be implemented.

12. A computer program product, characterized in that The computer program product is used to implement the method according to any one of claims 1 to 7.

Images