CN113296793A

CN113296793A - Application processing method and device, electronic equipment and medium

Info

Publication number: CN113296793A
Application number: CN202010754871.8A
Authority: CN
Inventors: 崔云汉
Original assignee: Alibaba Group Holding Ltd
Current assignee: Alibaba Group Holding Ltd
Priority date: 2020-07-30
Filing date: 2020-07-30
Publication date: 2021-08-24

Abstract

The embodiment of the application provides an application processing method, an application processing device, application processing equipment and an application processing medium, so that the cost is reduced. The method comprises the following steps: receiving a starting instruction aiming at a deployment container, wherein the deployment container corresponds to a container file package, and the container file package comprises a starting file package and at least two application file packages; responding to the starting instruction, and creating a process corresponding to the deployment container; and calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas. The method and the device can realize the loading and running of at least two application file packages by adopting one process, thereby reducing the cost.

Description

Application processing method and device, electronic equipment and medium

Technical Field

The present application relates to the field of computer technologies, and in particular, to an application processing method and apparatus, an electronic device, and a medium.

Background

A computer is a device with processing capabilities on which an application can be deployed so that the computer can provide services to users through the application. For example, an application for shopping may be deployed on a computer to cause the computer to provide shopping services to a user, and for example, an application for taxi taking may be deployed on a computer to cause the computer to provide taxi taking services to a user.

In the prior art, the main steps in deploying an application to a computer include: firstly, downloading an application file package to a computer; then, a process is started to load the application file package into the memory for running. Thus, deployment of multiple application packages requires support of multiple processes. For example, for 25 applications, if the application is deployed in 5 test environments for development, testing, pre-launch, sandboxing, and production, 5 × 25 — 125 processes are required, and if each computer supports the running of only one process, 125 computers are required.

It can be seen that the above method has a problem of high cost when deploying a plurality of applications.

Disclosure of Invention

The embodiment of the application provides an application processing method, so that a plurality of applications are merged and deployed, and the cost can be reduced.

Correspondingly, the embodiment of the application also provides an application processing device, equipment and a medium, which are used for ensuring the realization and the application of the method.

In order to solve the above problem, an embodiment of the present application discloses an application processing method, including: receiving a starting instruction aiming at a deployment container, wherein the deployment container corresponds to a container file package, and the container file package comprises a starting file package and at least two application file packages; responding to the starting instruction, and creating a process corresponding to the deployment container; and calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

The embodiment of the application also discloses another application processing method, which comprises the following steps: receiving a starting instruction of a deployment container aiming at a transaction type, wherein the deployment container corresponds to a container file package, the container file package comprises a starting file package and at least two application file packages, and the at least two application file packages correspond to applications of the transaction type; responding to the starting instruction, and creating a process corresponding to the deployment container; and calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

The embodiment of the application also discloses another application processing method, which comprises the following steps: receiving a starting instruction aiming at a deployment container of a marketing type, wherein the deployment container corresponds to a container file package, the container file package comprises a starting file package and at least two application file packages, and the at least two application file packages correspond to applications of the marketing type; responding to the starting instruction, and creating a process corresponding to the deployment container; and calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

The embodiment of the application also discloses another application processing method, which comprises the following steps: receiving a starting instruction aiming at a payment type deployment container, wherein the deployment container corresponds to a container file package, the container file package comprises a starting file package and at least two application file packages, and the at least two application file packages correspond to payment type applications; responding to the starting instruction, and creating a process corresponding to the deployment container; and calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

The embodiment of the application also discloses another application processing method, which comprises the following steps: calling a process corresponding to a deployment container to run a starting file package so as to control at least two loader instances to respectively load at least two application file packages into corresponding memory areas and control an application corresponding to the application file packages to run in the memory areas, wherein the deployment container corresponds to a container file package, and the container file package comprises the starting file package and the at least two application file packages; receiving an access request, wherein the access request comprises: a target access address; and under the condition that the target access address is matched with the target application address, processing the access request through an application corresponding to a target application file packet, wherein the target application address is the application access address corresponding to the target application file packet, and the target application file packet comprises one of at least two application file packets.

The embodiment of the application also discloses another application processing method, which comprises the following steps: downloading a container file package to target equipment, wherein the container file package is corresponding to a deployment container and comprises a starting file package and at least two application file packages; and calling a process corresponding to the deployment container on the target device to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

The embodiment of the application also discloses an application processing device, which comprises: the system comprises a first starting instruction receiving module, a first storage module and a first display module, wherein the first starting instruction receiving module is used for receiving a starting instruction aiming at a deployment container, the deployment container corresponds to a container file package, and the container file package comprises a starting file package and at least two application file packages; a first process creating module, configured to create, in response to the start instruction, a process corresponding to the deployment container; the first deployment module is used for calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

The embodiment of the application also discloses another application processing device, which comprises: a second starting instruction receiving module, configured to receive a starting instruction for a deployment container of a transaction type, where the deployment container corresponds to a container package, and the container package includes a starting package and at least two application packages, and the at least two application packages correspond to applications of the transaction type; the second process creating module is used for responding to the starting instruction and creating a process corresponding to the deployment container; the second deployment module is used for calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

The embodiment of the application also discloses another application processing device, which comprises: a third starting instruction receiving module, configured to receive a starting instruction for a deployment container of a marketing type, where the deployment container corresponds to a container package, the container package includes a starting package and at least two application packages, and the at least two application packages correspond to applications of the marketing type; a third process creating module, configured to create, in response to the start instruction, a process corresponding to the deployment container; and the third deployment module is used for calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

The embodiment of the application also discloses another application processing device, which comprises: a fourth starting instruction receiving module, configured to receive a starting instruction for a payment-type deployment container, where the deployment container corresponds to a container package, the container package includes a starting package and at least two application packages, and the at least two application packages correspond to payment-type applications; a fourth process creating module, configured to create, in response to the start instruction, a process corresponding to the deployment container; and the fourth deployment module is used for calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

The embodiment of the application also discloses another application processing device, which comprises: a fifth deployment module, configured to invoke a process corresponding to a deployment container to run a start-up package, so as to control at least two loader instances to load at least two application packages into corresponding memory regions respectively, and control an application corresponding to the application package to run in the memory region, where the deployment container corresponds to a container package, and the container package includes the start-up package and the at least two application packages; an access request receiving module, configured to receive an access request, where the access request includes: a target access address; and the access processing module is used for processing the access request through an application corresponding to a target application file package under the condition that the target access address is matched with a target application address, wherein the target application address is an application access address corresponding to the target application file package, and the target application file package comprises one of at least two application file packages.

The embodiment of the application also discloses another application processing device, which comprises: the system comprises a container file package downloading module, a container file package deploying module and a storage module, wherein the container file package downloading module is used for downloading a container file package to target equipment, the container file package is correspondingly provided with a container, and the container file package comprises a starting file package and at least two application file packages; a sixth deployment module, configured to invoke a process corresponding to the deployment container on the target device to run the start-up file package, so as to control at least two loader instances to respectively load an application file package into corresponding memory areas, and control an application corresponding to the application file package to run in the memory areas.

The embodiment of the application also discloses an electronic device, which comprises: a processor; and a memory having executable code stored thereon, which when executed, causes the processor to perform a method as in any one of the embodiments of the present application.

Embodiments of the application also disclose one or more machine-readable media having executable code stored thereon that, when executed, cause a processor to perform a method as any one of the embodiments of the application.

Compared with the prior art, the embodiment of the application has the following advantages:

in the embodiment of the application, deployment of the application can be achieved based on the deployment container, and the container file package of the deployment container includes at least two application file packages and a start file package, so that the process of the deployment container can run the start file package to control at least two loader instances to respectively load the at least two application file packages into corresponding memory areas to run.

Drawings

FIG. 1 is a schematic view of the loading of a container file package of the present application;

FIG. 2 is a flow chart of steps of an embodiment of an application processing method of the present application;

FIG. 3 is a schematic diagram of at least two applications of the present application running on a virtual machine with multiple tenants;

FIG. 4 is a schematic diagram of a process for a merge operation and maintenance system to build a container package;

FIG. 5 is a flow chart of steps in another embodiment of an application processing method of the present application;

FIG. 6 is a flow chart of steps in another embodiment of an application processing method of the present application;

FIG. 7 is a flow chart of steps in another embodiment of a method of application processing of the present application;

FIG. 8 is a flow chart of steps in another embodiment of a method of application processing of the present application;

FIG. 9 is a flowchart of the steps of another task processing method embodiment of the present application;

FIG. 10 is a block diagram of an embodiment of an application processing apparatus of the present application;

FIG. 11 is a block diagram of another embodiment of an application processing apparatus according to the present application;

FIG. 12 is a block diagram of another embodiment of an application processing apparatus according to the present application;

FIG. 13 is a block diagram of another embodiment of an application processing apparatus of the present application;

FIG. 14 is a block diagram of another embodiment of an application processing apparatus of the present application;

FIG. 15 is a block diagram of another embodiment of an application processing apparatus according to the present application;

fig. 16 is a schematic structural diagram of an apparatus according to an embodiment of the present application.

Detailed Description

In order to make the aforementioned objects, features and advantages of the present application more comprehensible, the present application is described in further detail with reference to the accompanying drawings and the detailed description.

The method and the device for deploying the application on the target device are used for deploying at least two applications on the target device in a deployment container mode, container file packages of the deployment container comprise a starting file package and at least two application file packages, the container file package is an executable file package, the starting file package is a kernel file package of the deployment container and is used for realizing loading and running logics of the at least two application file packages, the application file packages are file packages corresponding to the deployed applications, and the application file packages are used for realizing logics of services provided by the applications. A deployment container may also be understood as a shell application, which is an application after merging multiple applications.

It will be appreciated that the purpose of deploying the deployment container onto the target device is to deploy at least two applications onto the target device, which after deployment, a user can access to obtain services provided by the applications, e.g., there are two application packages: one of the application packages is used to implement the code logic of the taxi taking service, and the other application package is used to implement the code logic of the modern driving service, so that after the deployment container is deployed on the target device, the user can access the target device to obtain the taxi taking service and the designated driving service.

The target device may be any device with processing capabilities, including but not limited to: the computer, the terminal device, and of course the target device may also be referred to as a server when providing the service.

In order to reduce the number of processes, one process can be adopted for one deployment container, and the container file package of one deployment container comprises at least two application file packages, so that at least two application file packages are deployed by adopting one process, and the number of processes can be obviously reduced compared with the case that each application file package is deployed by adopting one process.

However, deploying at least two application packages using one process has the following problems: for example, if two application file packages APB1 and APB2 both modify a variable with a name, APB1 modifies the value of the variable to name1 and APB2 modifies the value of the variable to name2, which may cause the application file packages to have a conflict during operation.

In order to solve the above problems, different application file packages are loaded to different memory areas by different loader instances to run. As shown in fig. 1, taking four application file packages APB1, APB2, APB3, and APB4 as an example for explanation, there are four loader instances LD1, LD2, LD3, and LD4, and four memory areas WS1, WS2, WS3, and WS4, loader instance LD1 loads application file package APB1 into memory area WS1, loader instance LD2 loads application file package APB2 into memory area WS2, loader instance LD3 loads application file package APB3 into memory area WS3, and loader instance LD4 loads application file package APB4 into memory area WS 4. Therefore, the purpose of isolating the application file packages in the memory area is achieved, and the variables and the files corresponding to different application file packages are in different memory areas, so that the variables and the files corresponding to different application file packages are not influenced mutually and have no conflict even if the names of the variables and the files are the same, each application file package only modifies the variables and the files in the corresponding memory area, and does not modify the variables and the files in the corresponding memory area of another application file package.

As can be seen from fig. 1, the startup package is executed by the engine of the Server, and the startup package is an executable package, for example, Jar (Java Archive) package, where Java is an object-oriented programming language, so that the Server can be apache tomcat, which is a stand-alone WEB Server and Servlet (Server Applet) container, and can deploy and execute one or more War (WEB Archive) packages, and the main components of apache tomcat include but are not limited to: engine (only one), virtual site Host (multiple hosts), load run component Context (multiple hosts), loader WebAppLoader (multiple hosts), loader webapploadloader (multiple hosts), and loader webapploadbase (multiple hosts) for loading classes, configuration files, etc. in application packages. Each component of ApacheTomcat has a life cycle, the ApacheTomcat maintains the start, load, run, end and life cycle state notifications of each component, and the start of the ApacheTomcat is the ignition start of each component from the outside to the inside in the hierarchical order.

The starting module in fig. 1 is used to implement starting of the deployment container, the monitoring module is used to implement monitoring of the application in the running process, and the configuration module is used to invoke the configuration file to implement configuration of the application.

Based on the container package, the present application is described in detail below in several embodiments, and the steps in the following embodiments are performed by the deployed target device.

Referring to fig. 2, a flowchart illustrating steps of an embodiment of an application processing method according to the present application is shown, and specifically includes the following steps:

step 101, receiving a starting instruction for a deployment container, where the deployment container corresponds to a container package, and the container package includes a starting package and at least two application packages.

Wherein the container package is an operational package comprising: class, resource file, class or resource file dependent Jar package, the container package can be a FatJar (Fat Java Archive) package, the FatJar package is a format of Jar containing Jar, JDK (Java Development Kit, Java Development platform) does not support reading of Jar containing Jar package itself, and needs to rewrite a class loader supporting Jar containing Jar, such as SpringBoot (a kind of boot framework).

The startup package is an executable package, the application package is an archive file compression package that is not directly executable, for example, the startup package may be Jar package, the application package may be War package, War package is an executable package Jar compressed Zip package, War package is the minimum deployment unit of the application, War package itself is not executable, and needs to be loaded and executed by Servlet container (for example, apache tomcat), the application package includes but is not limited to: class, resource file, Jar package on which the class or resource file depends.

And 102, responding to the starting instruction, and creating a process corresponding to the deployment container.

It can be understood that the process of deploying the container is not only used for starting the deployment container, but also used for running the application corresponding to the application file package after the deployment is completed.

Step 103, invoking the process to run the startup file package to control at least two loader instances to respectively load the application file package into the corresponding memory regions, and to control the application corresponding to the application file package to run in the memory regions.

Specifically, the way to run the startup package is related to the Servlet container used, and the SpringBoot provides two ways of starting the EmbededTomcat (embedded Tomcat) and declaring that the entry of Servlet3 is loaded and started by ApacheTomcat as War package.

Wherein, EmbededTomcat is the embedded version of ApacheTomcat, has all the components and functions of ApacheTomcat, and is different from ApacheTomcat in that many functions, parameters and components of EmbededTomcat need custom configuration.

Servlet3 is the J2EE (Java 2Platform Enterprise Edition) standard, Servlet3 provides a container initialization interface ServletContainerInitializer, so that after the class of the Servlet containerinitializer is realized, an entry class of a Servlet container execution application can be declared, the Servlet container conforming to the Servlet3 standard can load the entry class of the application through the SPI, and the Servlet container can call the startup method onStartUp of the Servlet container execution application.

It is understood that running the boot package may implement: the method comprises the steps of controlling at least two loader instances to respectively load application file packages into corresponding memory areas, and controlling the applications corresponding to the application file packages to run in the memory areas, wherein the loader instances can be instances of application loading class WebAppLoaders, the memory areas can be memory areas corresponding to Context components Context, and each application file package is loaded into the memory area corresponding to the corresponding Context component Context by the instances of the corresponding application loading class WebAppLoaders.

Optionally, the controlling the application corresponding to the application file package in step 103 to run in the memory region includes sub-steps 1031 to 1032:

and a substep 1031, obtaining a global object, and generating a mirror image object corresponding to the global object in a memory region corresponding to the application file package, where the global object includes an object shared by the plurality of application file packages.

The global object may be a file, a frame, and the like, for example, a system file, a JMX (Java Management Extensions) frame, where the JMX is used for managing the application to monitor basic information and running conditions of the application.

It can be understood that the global object is an object that can be used by each application file package, so that to avoid a conflict, the global object needs to be copied to each memory region to obtain a mirror image object corresponding to the memory region, and the number of the mirror image objects corresponds to the number of the memory regions.

And a substep 1032, controlling the application corresponding to the application file packet to call the corresponding mirror image object in the memory region to run in the memory region.

Specifically, when the global object is a JMX frame, the mirror object is also a JMX frame, so that the basic information and the running condition of the application can be monitored through the JMX frame; when the global object is a system file, the system file may be modified.

When the application is operated, a multi-tenant technology can be adopted, wherein the multi-tenant technology is a software architecture technology, and the isolation among the applications can be ensured on the premise that the multiple applications share the same process. In the present application, different applications are run on different tenants of a JVM (Java Virtual Machine), and each tenant can apply for an independent memory area and monitor the running state of the application. As shown in fig. 3, 4 applications APP1, APP2, APP3, APP4 are respectively run in four tenants TN1, TN2, TN3, TN4 of the Java virtual machine, and target resource information corresponding to the 4 tenants is RS1, RS2, RS3, RS4, so that each tenant can monitor used real-time resource information and control the real-time resource information to conform to the corresponding target resource information.

The method and the device can call the mirror image object in each memory area to run the application in the memory area, thereby avoiding call conflict of different applications to the common object and realizing more accurate isolation among different applications.

Optionally, the method further comprises step 104:

and 104, calling the process to monitor the running state information of the application corresponding to the application file package.

The operation state information may include, but is not limited to: information on whether the application is abnormal, processor resources and memory resources occupied in the running process of the application. For example, as shown in fig. 1, the monitoring module may implement the running state information of the application file package, so that the engine may call the monitoring module to implement monitoring of the running state information, and the monitoring module may be packaged in the container file package as a basic function of the deployment container.

In practical application, the monitored running state information can be recorded, so that the performance and problems of the application can be conveniently analyzed and processed.

According to the method and the device, the running state information can be monitored through the process of the deployment container, so that the increase of the number of processes can be avoided, and the running state of the application can be in a controllable state.

Optionally, the method further comprises step 105:

and 105, calling the process to display the running state information of the application corresponding to the application file package.

Specifically, when the deployed target device has a display screen, the running state information can be displayed on the display screen in real time; when the deployed target device does not have a display screen, the running state information can be sent to the other devices connected with the target device, so that the running state information is displayed on the display screen of the device.

According to the method and the device, the running state information can be displayed through the process of the deployment container, so that the increase of the number of the processes can be avoided, and the running state information can be in a visible state.

Optionally, the running state information includes information about whether an application corresponding to the application file package runs abnormally, and the method further includes step 106:

and 106, calling the process to perform exception prompting under the condition that the application corresponding to at least one application file package runs abnormally.

The exception prompting is realized through exception information, and the form of the exception information includes but is not limited to: text, sound, light. When the exception prompt is carried out, the exception application can be indicated so as to be convenient for carrying out exception processing on the exception application as soon as possible.

The method and the device can prompt the exception through the process of the deployment container, so that the increase of the number of the processes can be avoided, and the exception of the application can be prompted.

Optionally, the running state information includes target resource information of an application corresponding to the application file package, and the method further includes steps 107 to 108:

step 107, obtaining a resource configuration instruction, where the resource configuration instruction includes the application file package and target resource information of an application corresponding to the application file package.

The target resource information may include, but is not limited to: maximum used memory, maximum processor occupancy, where the maximum used memory may be represented by the size of a memory space, for example, the memory that can be used by an application in the running process may be allowed to be 50MB, and then the maximum used memory of the application is 50 MB; the maximum processor occupancy may be the ratio of the time that the application occupies the processor to the total time that the processor is occupied, for example, the application may be allowed to occupy the processor for up to 3 seconds in 1 minute, and the maximum processor occupancy may be 3/60-5%.

In practical application, the resource configuration instruction may be an instruction initiated by a user after configuring the target resource information on the configuration interface, or an instruction for the user to modify the target resource information in the configuration file.

Step 108, responding to the resource configuration instruction, and configuring corresponding target resource information for the application corresponding to the application file packet.

Specifically, the configuration module may read corresponding target resource information from the configuration file according to the identifier of the application file package. As shown in fig. 1, when starting an application, an engine may obtain target resource information corresponding to the application from a configuration file through a configuration module.

Based on steps 107 to 108, the step 103 of controlling the application corresponding to the application file package to run in the memory region includes a substep 1033:

and a substep 1033 of controlling the application corresponding to the application file packet to run in the memory region by using the target resource information.

Specifically, the memory used by the control application in the running process is less than or equal to the maximum used memory, and the occupancy rate of the control application to the processor is less than or equal to the maximum processor occupancy rate.

The method and the device can configure the target resource information for the application so as to accurately control the application to run with the target resource information in the running process, and avoid the influence on the normal running of other applications caused by overlarge resource use by one application.

Optionally, the method further comprises step 109:

and step 109, stopping running the applications corresponding to the other application file packages under the condition that the application corresponding to at least one application file package fails to run.

In order to ensure that each application in the deployment container is started successfully, the method and the system can inherit a Fast-Fail processor, and after one Context fails to be started, the deployment container is blocked from being started, so that the aim of stopping running other applications is fulfilled. According to the scenario, after the deployment container is successfully started, each application is successfully started, and the situation that after the deployment container is successfully started, part of the applications cannot provide services due to failed starting is avoided.

Optionally, the method further comprises step 110:

and step 110, under the condition that the application corresponding to at least one application file package fails to run, continuing to run the applications corresponding to the other application file packages.

According to the method and the device, the other applications can be continuously operated under the condition that one application fails to operate, so that the Fast-Fail processor is not inherited, and the processor cannot block the starting of the deployment container after one Context fails to start, so that the aim of continuously operating the other applications is fulfilled. The application in the deployment container can be started as much as possible in the scene, so that the normally started application can provide service, and the influence of abnormal application on normal application is avoided.

Optionally, the method further comprises steps 111 to 113:

and step 111, acquiring a starting file package and at least two application file packages.

The starting file package and the application file package can be obtained by constructing through a file package construction tool and stored in the storage device. As shown in fig. 4, in the merged operation and maintenance system, files of applications APP1, APP2, APP3, and APP4 may be input into a package building tool, an application package APB1 corresponding to the application APP1, an application package APB2 corresponding to the application APP2, an application package APB3 corresponding to the application APP3, and an application package APB4 corresponding to the application APP4 are obtained, a start file may be input into the package building tool, a start package is obtained, and the application packages APB1, APB2, APB3, APB4, and the start package may all be temporarily stored in a storage device.

The above-mentioned file package construction tool is any tool that can construct a file package according to a dependency relationship, for example, a maven construction tool and an ant construction tool, the maven has all functions of an ant, and further has the following characteristics: project management is carried out on the application by using an engineering Object Model Project Object Model, more built-in implicit rules than ant enable the file package to be built more simply, and management and unified storage of dependence are realized by built-in dependence management; the lifecycle of the application build is built in. Based on the characteristics, the construction tool can be selected according to the requirements in practical application.

The description of the present application takes a maven tool as an example, when the portfolio building tool is a maven building tool, the storage device may be a maven repository, the maven tool is a project management tool, the maven tool may build a plurality of files into one portfolio according to a dependency relationship between classes within the same file and a dependency relationship between classes among a plurality of files, for example, a plurality of files of the application APP1 are included, so that a plurality of files of the APP1 may be built into the application portfolio APB1 according to a dependency relationship between classes within a plurality of files of the APP1 and a dependency relationship between classes among a plurality of files.

The Maven warehouse can be used for managing constructed file packages such as Jar and War and can also be used for managing files such as reports and documents.

Step 112, storing the start-up file package into a first folder, and storing the at least two application file packages into corresponding second folders, respectively.

It should be noted that each application file package is stored in a separate second folder.

Step 113, constructing the starting file package in the first folder and the application file package in the second folder into a container file package.

According to the method and the device, each file package can be stored in one folder, and then the container file package is constructed based on the folders, so that the dependency relationship inside the file package in each folder cannot be transmitted to the outside of the folders, the dependency relationship among the folders is avoided, the dependency conflict among different application file packages and the dependency conflict between the application file package and the starting file package are avoided, and the isolation in the construction stage is realized.

Optionally, the method further comprises step 114:

step 114, running the start-up file package through the process to control at least two loader instances to respectively load a preset common component into the memory areas corresponding to the application file package, where the preset common component is called in the running of the application file package.

The preset common component is a component that can be called by multiple application file packages, so that each loader instance needs to load the preset common component into a respective memory area, and the preset common component can be loaded in a file package form, for example, the file package of the preset common component can be a Sar package. As shown in fig. 1, the four loader instances LD1, LD2, LD3, and LD4 may load the preset common component into the memory areas WS1, WS2, WS3, and WS4, so that the application file package APB1 may call the preset common component from the memory area WS1, the application file package APB2 may call the preset common component from the memory area WS2, the application file package APB3 may call the preset common component from the memory area WS3, and the application file package APB4 may call the preset common component from the memory area WS 4.

It can be understood that, when the loading of the application file package depends on the preset common component, the preset common component needs to be loaded before the application file package is loaded, for example, the preset common component is used for a loading process of the canonical application file package, the preset common component may be loaded in advance, and then the canonical loading application file package of the preset common component is called; when the loading of the application file package is not dependent on the preset common component, the loading sequence of the application file package and the preset common component may not be limited.

The application can support loading of the preset public component, so that the application file package can call the preset public component, and development cost consumed by realizing the function of the preset public component is reduced.

Optionally, the at least two application packages comprise: at least two application file packages of the same type, the type comprising: transaction type, marketing type, payment type.

The type of the application file package may be determined according to a service provided by an application corresponding to the application file package, for example, when the application corresponding to the application file package provides a transaction service, the type of the application file package is a transaction type; when the application corresponding to the application file package provides marketing advertisement service, the type of the application file package is a marketing type; when the application corresponding to the application file package provides payment service, the type of the application file package is a payment type.

The above types may be associated in actual use, for example, depending on the order of use, payment may be made with a payment type application APP2 after using up a transaction type application APP 1.

According to the application file package deployment method and device, the application file packages of the same type or the associated types can be deployed at one time through the deployment container, the applications of the associated types can be conveniently accessed, and the applications of the same type can be conveniently compared.

In summary, the application processing method provided by the present application can implement application deployment based on a deployment container, where a container file package of the deployment container includes at least two application file packages and a start file package, so that a process of the deployment container can run the start file package to control at least two loader instances to respectively load the at least two application file packages into corresponding memory regions for running, and thus, loading and running of the at least two application file packages are implemented by using one process, which reduces cost.

Referring to fig. 5, a flowchart of steps of another embodiment of an application processing method of the present application is shown, and specifically includes the following steps:

step 201, receiving a starting instruction of a deployment container for a transaction type, where the deployment container corresponds to a container file package, and the container file package includes a starting file package and at least two application file packages, and the at least two application file packages correspond to applications of the transaction type.

Wherein, the transaction type application is used to provide transaction service for the user, the user can purchase goods or services through the application, and the object of the transaction can include but is not limited to: the physical goods, virtual services, for example, the object of transaction can be daily necessities, massage services, and the like.

Step 202, in response to the start instruction, creating a process corresponding to the deployment container.

Step 203, invoking the process to run the startup file package, so as to control at least two loader instances to respectively load the application file package into the corresponding memory regions, and control the application corresponding to the application file package to run in the memory regions.

In this embodiment, the steps 201 to 203 may refer to the detailed descriptions of the steps 101 to 103, which are not described herein again.

Referring to fig. 6, a flowchart of steps of another embodiment of an application processing method of the present application is shown, and specifically includes the following steps:

step 301, receiving a starting instruction for a deployment container of a marketing type, where the deployment container corresponds to a container file package, and the container file package includes a starting file package and at least two application file packages, where the at least two application file packages correspond to applications of the marketing type.

Wherein the marketing-type application is used to provide a marketing service to a user, through which the user can sell goods or services. For example, the user may sell commodity, the user may provide a massage service, and the like.

Step 302, in response to the start instruction, creating a process corresponding to the deployment container.

Step 303, invoking the process to run the startup file package to control at least two loader instances to respectively load the application file package into the corresponding memory regions, and to control the application corresponding to the application file package to run in the memory regions.

Referring to fig. 7, a flowchart of steps of another embodiment of an application processing method of the present application is shown, and specifically includes the following steps:

step 401, receiving a starting instruction for a payment type deployment container, where the deployment container corresponds to a container file package, where the container file package includes a starting file package and at least two application file packages, and the at least two application file packages correspond to payment type applications.

The payment type application is used for providing payment service for the user, and the user can carry out payment operation through the application.

Step 402, in response to the starting instruction, creating a process corresponding to the deployment container.

Step 403, invoking the process to run the startup file package, so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas, and control the application corresponding to the application file package to run in the memory areas.

Referring to fig. 8, a flowchart of steps of another embodiment of an application processing method of the present application is shown, and specifically includes the following steps:

step 501, invoking a process corresponding to a deployment container to run a start-up file package, so as to control at least two loader instances to respectively load at least two application file packages into corresponding memory areas, and control an application corresponding to the application file packages to run in the memory areas, where the deployment container corresponds to a container file package, and the container file package includes the start-up file package and the at least two application file packages.

This step can refer to the detailed description of steps 101 to 103, which is not described herein.

Step 502, receiving an access request, wherein the access request comprises: the target access address.

The access request is used to access an application, and the access request may be an HTTP (Hyper Text Transfer Protocol) request. When the accessed application is an application corresponding to one application file package in the container file package, the deployment container can distribute the access request to the corresponding application; when the application is not an application file in the container package, the deployment container denies the access request. When the deployment container receives an access request, matching a target access address in the access request with an application access address corresponding to each application file package in the container file package, and if the target access address is successfully matched with the application access address of one application file package, distributing the access request to an application corresponding to the application file package; and if the matching with the application access address of any application file packet fails, rejecting the access request.

In practical applications, the deployment container may be provided with a monitoring interface, configured to monitor the access request, and forward the access request to the distribution interface after monitoring the access request, and the distribution interface may distribute the access request to a corresponding application.

Step 503, under the condition that the target access address is matched with the target application address, processing the access request through an application corresponding to a target application file package, where the target application address is an application access address corresponding to the target application file package, and the target application file package includes one application file package of at least two application file packages.

It is understood that the target application file package is an application file package with an application access address matched with the target access address, and the application access address can be formed by a class, an interface and a path of a method for providing services by an application.

Referring to fig. 9, a flowchart of steps of another embodiment of an application processing method of the present application is shown, and specifically includes the following steps:

step 601, downloading a container file package to a target device, wherein the container file package is corresponding to a deployment container, and the container file package comprises a starting file package and at least two application file packages.

The target device may be any device with processing capability, including but not limited to: the computer, the terminal device, and of course the target device may also be referred to as a server when providing the service.

In practical application, the container file package can be manually downloaded from the storage device to the target device, and the storage device can also actively release the container file package to the target device according to a certain strategy.

Step 602, invoking a process corresponding to the deployment container on the target device to run the startup file package, so as to control at least two loader instances to respectively load an application file package into corresponding memory areas, and control an application corresponding to the application file package to run in the memory areas.

Specifically, a process for deploying the container may be created on the target device, and the process is invoked to run the start-up file package by using the hardware resource on the target device, so as to control the at least two loader instances to respectively load the application file package into the corresponding memory areas on the target device, and the application corresponding to the application file package runs in the memory area of the target device. The at least two applications are deployed on the target device through the deployment container, so that the at least two applications can be loaded and run through one process on the target device. For example, for 25 applications, if 25 applications are deployed in 5 target devices, which are development, testing, pre-launching, sandboxing and production, 25 applications may be merged and deployed through one deployment container, one deployment container is deployed on each target device, and each deployment container needs one process, so that 5 processes are needed when 25 applications are deployed on 5 target devices; each 5 applications may also be merged and deployed through one deployment container, so that 25 applications need to be deployed through 5 deployment containers, the 5 deployment containers are deployed on each target device, each deployment container needs one process, and 5 × 5 processes are needed when 25 applications are deployed on 5 target devices.

Referring to fig. 10, a block diagram of an embodiment of an application processing apparatus according to the present application is shown, and specifically includes the following modules:

a first starting instruction receiving module 701, configured to receive a starting instruction for a deployment container, where the deployment container corresponds to a container package, and the container package includes a starting package and at least two application packages.

A first process creating module 702, configured to create, in response to the start instruction, a process corresponding to the deployment container.

The first deployment module 703 is configured to invoke the process to run the boot package, so as to control at least two loader instances to respectively load the application package into corresponding memory areas, and control an application corresponding to the application package to run in the memory areas.

Optionally, the first deployment module 703 includes a global object obtaining sub-module and a first running sub-module:

and the global object obtaining submodule is used for obtaining a global object and generating a mirror image object of the global object in a memory area corresponding to the application file packet, wherein the global object comprises an object shared by the plurality of application file packets.

And the first operation sub-module is used for controlling the application corresponding to the application file package to call the corresponding mirror image object in the memory area to operate in the memory area.

Optionally, the apparatus further includes an operation status information monitoring module:

and the running state information monitoring module is used for calling the process to monitor the running state information of the application corresponding to the application file package.

Optionally, the apparatus further comprises an operation status information display module:

and the running state information display module is used for calling the process to display the running state information of the application corresponding to the application file package.

Optionally, the running state information includes information about whether an application corresponding to the application file package runs abnormally, and the apparatus further includes an abnormality prompt module:

and the exception prompting module is used for calling the process to perform exception prompting under the condition that the application corresponding to at least one application file package runs abnormally.

Optionally, the running state information includes target resource information of an application corresponding to the application file package, and the apparatus further includes a resource configuration instruction obtaining module and a target resource information configuration module:

and the resource configuration instruction acquisition module is used for acquiring a resource configuration instruction, wherein the resource configuration instruction comprises the application file packet and target resource information of the application corresponding to the application file packet.

And the target resource information configuration module is used for responding to the resource configuration instruction and configuring corresponding target resource information aiming at the application corresponding to the application file packet.

Based on the resource configuration instruction obtaining module and the target resource information configuring module, the first deployment module 703 includes a second operation sub-module:

and the second operation sub-module is used for controlling the application corresponding to the application file packet to operate in the memory area by using the target resource information.

Optionally, the apparatus further comprises a first stop processing module:

and the first stop processing module is used for stopping running the applications corresponding to the other application file packages under the condition that the running of the application corresponding to at least one application file package fails.

Optionally, the apparatus further comprises a second stop processing module:

and the second stop processing module is used for continuously running the applications corresponding to the other application file packages under the condition that the application corresponding to at least one application file package fails to run.

Optionally, the apparatus further includes a file package obtaining module, a respective storage module, and a container file package constructing module:

and the file package acquisition module is used for acquiring the starting file package and at least two application file packages.

And the respective storage module is used for storing the starting file package into a first folder and storing the at least two application file packages into corresponding second folders respectively.

And the container file package constructing module is used for constructing the starting file package in the first folder and the application file package in the second folder into a container file package.

Optionally, the apparatus further comprises a common component loading module:

and the public component loading module is used for operating the starting file package through the process so as to control at least two loader instances to respectively load a preset public component into the memory area corresponding to the application file package, wherein the preset public component is called in the operation of the application file package.

In summary, the application processing apparatus provided in the present application may implement application deployment based on a deployment container, where a container file package of the deployment container includes at least two application file packages and a start file package, so that a process of the deployment container may run the start file package to control at least two loader instances to respectively load the at least two application file packages into corresponding memory regions for running, and thus, a process is used to implement loading and running of the at least two application file packages, thereby reducing cost.

Referring to fig. 11, a block diagram of another embodiment of an application processing apparatus according to the present application is shown, and specifically includes the following modules:

a second starting instruction receiving module 801, configured to receive a starting instruction for a deployment container of a transaction type, where the deployment container corresponds to a container package, and the container package includes a starting package and at least two application packages, and the at least two application packages correspond to applications of the transaction type.

A second process creating module 802, configured to create, in response to the start instruction, a process corresponding to the deployment container.

A second deployment module 803, configured to invoke the process to run the start-up file package, so as to control at least two loader instances to respectively load the application file package into corresponding memory areas, and control an application corresponding to the application file package to run in the memory areas.

Referring to fig. 12, a block diagram of another embodiment of an application processing apparatus according to the present application is shown, and specifically includes the following modules:

a third starting instruction receiving module 901, configured to receive a starting instruction for a deployment container of a marketing type, where the deployment container corresponds to a container file package, and the container file package includes a starting file package and at least two application file packages, where the at least two application file packages correspond to applications of the marketing type.

A third process creating module 902, configured to create, in response to the start instruction, a process corresponding to the deployment container.

A third deployment module 903, configured to invoke the process to run the boot package, so as to control at least two loader instances to respectively load the application package into corresponding memory areas, and control an application corresponding to the application package to run in the memory areas.

Referring to fig. 13, a block diagram of another embodiment of an application processing apparatus according to the present application is shown, and specifically includes the following modules:

a fourth start instruction receiving module 1001, configured to receive a start instruction for a payment-type deployment container, where the deployment container corresponds to a container package, and the container package includes a start package and at least two application packages, and the at least two application packages correspond to payment-type applications.

A fourth process creating module 1002, configured to create a process corresponding to the deployment container in response to the start instruction.

A fourth deployment module 1003, configured to invoke the process to run the startup file package, so as to control at least two loader instances to respectively load the application file package into corresponding memory areas, and control an application corresponding to the application file package to run in the memory areas.

Referring to fig. 14, a block diagram of another embodiment of an application processing apparatus according to the present application is shown, and specifically includes the following modules:

a fifth deployment module 1101, configured to invoke a process corresponding to a deployment container to run a start-up package, so as to control at least two loader instances to load at least two application packages into corresponding memory regions respectively, and control an application corresponding to the application package to run in the memory region, where the deployment container corresponds to a container package, and the container package includes the start-up package and the at least two application packages.

An access request receiving module 1102, configured to receive an access request, where the access request includes: the target access address.

An access processing module 1103, configured to, when the target access address is matched with a target application address, process the access request through an application corresponding to a target application file package, where the target application address is an application access address corresponding to the target application file package, and the target application file package includes one application file package of at least two application file packages.

Referring to fig. 15, a block diagram of another embodiment of an application processing apparatus according to the present application is shown, and specifically includes the following modules:

a container package downloading module 1201, configured to download a container package onto a target device, where the container package corresponds to a deployment container, and the container package includes a start package and at least two application packages.

A sixth deployment module 1202, configured to invoke a process corresponding to the deployment container on the target device to run the start-up file package, so as to control at least two loader instances to respectively load an application file package into corresponding memory areas, and control an application corresponding to the application file package to run in the memory areas.

The present application further provides a non-transitory, readable storage medium, where one or more modules (programs) are stored, and when the one or more modules are applied to a device, the device may execute instructions (instructions) of method steps in this application.

Embodiments of the present application provide one or more machine-readable media having instructions stored thereon, which when executed by one or more processors, cause an electronic device to perform the methods as described in one or more of the above embodiments. In the embodiment of the present application, the electronic device includes various types of devices such as a terminal device and a server (cluster).

Embodiments of the present disclosure may be implemented as an apparatus, which may include electronic devices such as a terminal device, a server (cluster), etc., using any suitable hardware, firmware, software, or any combination thereof, to perform a desired configuration. Fig. 16 schematically illustrates an example apparatus 1300 that can be used to implement various embodiments described herein.

For one embodiment, fig. 16 illustrates an example apparatus 1300 having one or more processors 1302, a control module (chipset) 1304 coupled to at least one of the processor(s) 1302, memory 1306 coupled to the control module 1304, non-volatile memory (NVM)/storage 1308 coupled to the control module 1304, one or more input/output devices 1310 coupled to the control module 1304, and a network interface 1312 coupled to the control module 1304.

Processor 1302 may include one or more single-core or multi-core processors, and processor 1302 may include any combination of general-purpose or special-purpose processors (e.g., graphics processors, application processors, baseband processors, etc.). In some embodiments, the apparatus 1300 can be used as a terminal device, a server (cluster), and other devices described in this embodiment.

In some embodiments, apparatus 1300 may include one or more computer-readable media (e.g., memory 1306 or NVM/storage 1308) having instructions 1314 and one or more processors 1302, which in combination with the one or more computer-readable media, are configured to execute instructions 1314 to implement modules to perform actions described in this disclosure.

For one embodiment, control module 1304 may include any suitable interface controllers to provide any suitable interface to at least one of the processor(s) 1302 and/or any suitable device or component in communication with control module 1304.

The control module 1304 may include a memory controller module to provide an interface to the memory 1306. The memory controller module may be a hardware module, a software module, and/or a firmware module.

Memory 1306 may be used, for example, to load and store data and/or instructions 1314 for device 1300. For one embodiment, memory 1306 may comprise any suitable volatile memory, such as suitable DRAM. In some embodiments, the memory 1306 may comprise a double data rate type four synchronous dynamic random access memory (DDR4 SDRAM).

For one embodiment, control module 1304 may include one or more input/output controllers to provide an interface to NVM/storage 1308 and input/output device(s) 1310.

For example, NVM/storage 1308 may be used to store data and/or instructions 1314. NVM/storage 1308 may include any suitable non-volatile memory (e.g., flash memory) and/or may include any suitable non-volatile storage device(s) (e.g., one or more Hard Disk Drives (HDDs), one or more Compact Disc (CD) drives, and/or one or more Digital Versatile Disc (DVD) drives).

NVM/storage 1308 may include storage resources that are physically part of the device on which apparatus 1300 is installed, or it may be accessible by the device and need not be part of the device. For example, NVM/storage 1308 may be accessible over a network via input/output device(s) 1310.

Input/output device(s) 1310 may provide an interface for apparatus 1300 to communicate with any other suitable device, input/output device(s) 1310 may include communication components, audio components, sensor components, and so forth. The network interface 1312 may provide an interface for the device 1300 to communicate over one or more networks, and the device 1300 may wirelessly communicate with one or more components of a wireless network according to any of one or more wireless network standards and/or protocols, such as access to a communication standard-based wireless network, e.g., WiFi, 2G, 3G, 4G, 5G, etc., or a combination thereof.

For one embodiment, at least one of the processor(s) 1302 may be packaged together with logic for one or more controllers (e.g., memory controller modules) of the control module 1304. For one embodiment, at least one of the processor(s) 1302 may be packaged together with logic for one or more controllers of the control module 1304 to form a System In Package (SiP). For one embodiment, at least one of the processor(s) 1302 may be integrated on the same die with logic for one or more controller(s) of the control module 1304. For one embodiment, at least one of the processor(s) 1302 may be integrated on the same die with logic of one or more controllers of the control module 1304 to form a system on chip (SoC).

In various embodiments, apparatus 1300 may be, but is not limited to being: a server, a desktop computing device, or a mobile computing device (e.g., a laptop computing device, a handheld computing device, a tablet, a netbook, etc.), among other terminal devices. In various embodiments, apparatus 1300 may have more or fewer components and/or different architectures. For example, in some embodiments, device 1300 includes one or more cameras, a keyboard, a Liquid Crystal Display (LCD) screen (including a touch screen display), a non-volatile memory port, multiple antennas, a graphics chip, an Application Specific Integrated Circuit (ASIC), and speakers.

The apparatus 1300 may employ a main control chip as a processor or a control module, the sensor data, the location information, and the like are stored in a memory or an NVM/storage device, the sensor group may serve as an input/output device, and the communication interface may include a network interface.

For the device embodiment, since it is basically similar to the method embodiment, the description is simple, and for the relevant points, refer to the partial description of the method embodiment.

The embodiments in the present specification are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same and similar parts among the embodiments are referred to each other.

Embodiments of the present application are described with reference to flowchart illustrations and/or block diagrams of methods, terminal devices (systems), and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing terminal to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing terminal, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing terminal to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing terminal to cause a series of operational steps to be performed on the computer or other programmable terminal to produce a computer implemented process such that the instructions which execute on the computer or other programmable terminal provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

While preferred embodiments of the present application have been described, additional variations and modifications of these embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including the preferred embodiment and all such alterations and modifications as fall within the true scope of the embodiments of the application.

Finally, it should also be noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or terminal that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or terminal. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or terminal that comprises the element.

The application processing method, device, apparatus and medium provided by the present application are introduced in detail, and a specific example is applied in the description to explain the principle and the implementation of the present application, and the description of the above embodiment is only used to help understand the method and the core idea of the present application; meanwhile, for a person skilled in the art, according to the idea of the present application, there may be variations in the specific embodiments and the application scope, and in summary, the content of the present specification should not be construed as a limitation to the present application.

Claims

1. An application processing method, comprising:

receiving a starting instruction aiming at a deployment container, wherein the deployment container corresponds to a container file package, and the container file package comprises a starting file package and at least two application file packages;

responding to the starting instruction, and creating a process corresponding to the deployment container;

and calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

2. The method according to claim 1, wherein the controlling the application corresponding to the application file package to run in the memory area comprises:

acquiring a global object and generating a mirror image object of the global object in a memory area corresponding to the application file package, wherein the global object comprises an object shared by the application file packages;

and controlling the application corresponding to the application file packet to call the corresponding mirror image object in the memory area to run in the memory area.

3. The method of claim 1, further comprising:

and calling the process to monitor the running state information of the application corresponding to the application file package.

4. The method of claim 3, further comprising:

and calling the process to display the running state information of the application corresponding to the application file package.

5. The method according to claim 3, wherein the running state information includes information on whether an application corresponding to the application file package runs abnormally, and the method further comprises:

and calling the process to perform exception prompting under the condition that the application corresponding to at least one application file package runs abnormally.

6. The method of claim 3, wherein the operating state information includes target resource information of an application corresponding to the application package, and wherein the method further comprises:

acquiring a resource configuration instruction, wherein the resource configuration instruction comprises the application file packet and target resource information of an application corresponding to the application file packet;

responding to the resource configuration instruction, and configuring corresponding target resource information for the application corresponding to the application file packet;

the controlling the application corresponding to the application file package to run in the memory area includes:

and controlling the application corresponding to the application file packet to run in the memory area by using the target resource information.

7. The method according to any one of claims 1 to 6, further comprising:

and under the condition that the application corresponding to at least one application file package fails to run, stopping running the applications corresponding to the other application file packages.

8. The method according to any one of claims 1 to 6, further comprising:

and under the condition that the application corresponding to at least one application file package fails to run, continuing to run the applications corresponding to the other application file packages.

9. The method according to any one of claims 1 to 6, further comprising:

acquiring a starting file package and at least two application file packages;

storing the starting file package into a first folder, and storing the at least two application file packages into corresponding second folders respectively;

and constructing the starting file package in the first folder and the application file package in the second folder into a container file package.

10. The method according to any one of claims 1 to 6, further comprising:

and running the starting file package through the process to control at least two loader instances to respectively load a preset common component into the memory areas corresponding to the application file package, wherein the preset common component is called in the running of the application file package.

11. The method of claim 1, wherein the at least two application packages comprise: at least two application file packages of the same type, the type comprising: transaction type, marketing type, payment type.

12. An application processing method, comprising:

receiving a starting instruction of a deployment container aiming at a transaction type, wherein the deployment container corresponds to a container file package, the container file package comprises a starting file package and at least two application file packages, and the at least two application file packages correspond to applications of the transaction type;

13. An application processing method, comprising:

receiving a starting instruction aiming at a deployment container of a marketing type, wherein the deployment container corresponds to a container file package, the container file package comprises a starting file package and at least two application file packages, and the at least two application file packages correspond to applications of the marketing type;

14. An application processing method, comprising:

receiving a starting instruction aiming at a payment type deployment container, wherein the deployment container corresponds to a container file package, the container file package comprises a starting file package and at least two application file packages, and the at least two application file packages correspond to payment type applications;

15. An application processing method, comprising:

calling a process corresponding to a deployment container to run a starting file package so as to control at least two loader instances to respectively load at least two application file packages into corresponding memory areas and control an application corresponding to the application file packages to run in the memory areas, wherein the deployment container corresponds to a container file package, and the container file package comprises the starting file package and the at least two application file packages;

receiving an access request, wherein the access request comprises: a target access address;

and under the condition that the target access address is matched with the target application address, processing the access request through an application corresponding to a target application file packet, wherein the target application address is the application access address corresponding to the target application file packet, and the target application file packet comprises one of at least two application file packets.

16. An application processing method, characterized in that the method further comprises:

downloading a container file package to target equipment, wherein the container file package is corresponding to a deployment container and comprises a starting file package and at least two application file packages;

and calling a process corresponding to the deployment container on the target device to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

17. An application processing apparatus, comprising:

the system comprises a first starting instruction receiving module, a first storage module and a first display module, wherein the first starting instruction receiving module is used for receiving a starting instruction aiming at a deployment container, the deployment container corresponds to a container file package, and the container file package comprises a starting file package and at least two application file packages;

a first process creating module, configured to create, in response to the start instruction, a process corresponding to the deployment container;

the first deployment module is used for calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

18. An application processing apparatus, comprising:

a second starting instruction receiving module, configured to receive a starting instruction for a deployment container of a transaction type, where the deployment container corresponds to a container package, and the container package includes a starting package and at least two application packages, and the at least two application packages correspond to applications of the transaction type;

the second process creating module is used for responding to the starting instruction and creating a process corresponding to the deployment container;

the second deployment module is used for calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

19. An application processing apparatus, comprising:

a third starting instruction receiving module, configured to receive a starting instruction for a deployment container of a marketing type, where the deployment container corresponds to a container package, the container package includes a starting package and at least two application packages, and the at least two application packages correspond to applications of the marketing type;

a third process creating module, configured to create, in response to the start instruction, a process corresponding to the deployment container;

and the third deployment module is used for calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

20. An application processing apparatus, comprising:

a fourth starting instruction receiving module, configured to receive a starting instruction for a payment-type deployment container, where the deployment container corresponds to a container package, the container package includes a starting package and at least two application packages, and the at least two application packages correspond to payment-type applications;

a fourth process creating module, configured to create, in response to the start instruction, a process corresponding to the deployment container;

and the fourth deployment module is used for calling the process to run the starting file package so as to control at least two loader instances to respectively load the application file package into the corresponding memory areas and control the application corresponding to the application file package to run in the memory areas.

21. An application processing apparatus, comprising:

a fifth deployment module, configured to invoke a process corresponding to a deployment container to run a start-up package, so as to control at least two loader instances to load at least two application packages into corresponding memory regions respectively, and control an application corresponding to the application package to run in the memory region, where the deployment container corresponds to a container package, and the container package includes the start-up package and the at least two application packages;

an access request receiving module, configured to receive an access request, where the access request includes: a target access address;

and the access processing module is used for processing the access request through an application corresponding to a target application file package under the condition that the target access address is matched with a target application address, wherein the target application address is an application access address corresponding to the target application file package, and the target application file package comprises one of at least two application file packages.

22. An application processing apparatus, comprising:

the system comprises a container file package downloading module, a container file package deploying module and a storage module, wherein the container file package downloading module is used for downloading a container file package to target equipment, the container file package is correspondingly provided with a container, and the container file package comprises a starting file package and at least two application file packages;

a sixth deployment module, configured to invoke a process corresponding to the deployment container on the target device to run the start-up file package, so as to control at least two loader instances to respectively load an application file package into corresponding memory areas, and control an application corresponding to the application file package to run in the memory areas.

23. An electronic device, comprising: a processor; and

a memory having executable code stored thereon that, when executed, causes the processor to perform the method of any of claims 1 to 16.

24. One or more machine-readable media having executable code stored thereon that, when executed, causes a processor to perform the method of any of claims 1-16.