CN110442327B

CN110442327B - Application program construction method, device and server

Info

Publication number: CN110442327B
Application number: CN201810412640.1A
Authority: CN
Inventors: 俞静飞
Original assignee: Alibaba Group Holding Ltd
Current assignee: Alibaba Group Holding Ltd
Priority date: 2018-05-03
Filing date: 2018-05-03
Publication date: 2023-06-23
Anticipated expiration: 2038-05-03
Also published as: CN110442327A

Abstract

The application program construction method, device and server are provided, wherein the application program construction method comprises the following steps: hijack (hook) the application programming interface of the native object; extracting relevant configuration information of each business function module application program from the original object to generate a configuration file; and constructing an application program according to the configuration file and the application programs of the functional modules. By utilizing the technical scheme provided by the embodiment of the application, the application program compatible by other frame systems can be constructed by modifying the original plug-in to a small extent, so that the modification cost is reduced, and the backward compatibility is easy.

Description

Application program construction method, device and server

Technical Field

The application belongs to the technical field of computers, and particularly relates to an application program construction method, an application program construction device, a server and a storage medium.

Background

At present, a dynamically loaded modularized application technology, namely an android Instant application (Instant app), is supported on an android system, the technology changes the traditional mode of installing the application through an app store, allows the android native application to run immediately without installation, and is dynamically downloaded and used during running.

In the instance app technology, an application program is constructed as a set of a plurality of modularized application programs (feature apk), each feature corresponds to a functional module, and when a user needs one of the functions, only the functional module needs to be dynamically loaded, so that the system space occupied by the application program can be reduced, the loading speed is high, and the response efficiency is high.

It should be noted that the foregoing description of the background art is only for the purpose of providing a clear and complete description of the technical solution of the present invention and is presented for the convenience of understanding by those skilled in the art. The above-described solutions are not considered to be known to the person skilled in the art simply because they are set forth in the background of the invention section.

Disclosure of Invention

The inventor finds that the current instant app technology needs the support of the google play service, and only when the terminal equipment supports the google play service, the feature apk constructed under the instant app technology can be correctly analyzed, so that the compatibility is poor, and if the application developed by using the instant app technology needs to be transplanted to other frame systems, the native plug-in needs to be modified in a large scale, and the modification cost is high.

The embodiment of the application program constructing method, device, terminal equipment and storage medium can construct the application program compatible by other frame systems by modifying the original plug-in to a small extent, thereby reducing the modifying cost and being easy to be backwards compatible.

According to a first aspect of an embodiment of the present invention, there is provided an application program construction method, where the method includes:

hijack (hook) the application programming interface of the native object;

extracting relevant configuration information of each business function module application program from the original object to generate a configuration file;

and constructing an application program according to the configuration file and the application programs of the business function modules.

According to a second aspect of an embodiment of the present invention, there is provided a method as described in the first aspect, wherein the object comprises code and resources.

According to a third aspect of embodiments of the present invention, there is provided a method as described in the first aspect, wherein the configuration information includes access address information (url), size information and/or verification information of the service function module application.

According to a fourth aspect of embodiments of the present invention, there is provided a method as set forth in the first aspect, wherein the method further comprises: extracting a public object from each business function module of the original object according to the dependency relationship of each business function module;

and constructing an application program according to the configuration file, the public object and the application programs of the business function modules.

According to a fifth aspect of embodiments of the present invention, there is provided a method as set forth in the first aspect, wherein the method further includes: the package identification (packageID) of each business function module application is modified.

According to a sixth aspect of embodiments of the present invention, there is provided a method as set forth in the first or fourth aspect, wherein building an application comprises:

and the service function module application programs and the configuration files are added, or the service function module application programs and the common objects are shelled, so that the application programs are constructed.

According to a seventh aspect of an embodiment of the present invention, there is provided an application program construction apparatus, wherein the apparatus includes:

a hijacking unit for hijacking (hook) an application programming interface of the native object;

the generating unit is used for extracting relevant configuration information of each business function module application program from the original object and generating a configuration file;

and the construction unit is used for constructing application programs according to the configuration files and the application programs of the business function modules.

According to an eighth aspect of an embodiment of the present invention, there is provided an apparatus as described in the seventh aspect, wherein the object includes code and resources.

According to a ninth aspect of an embodiment of the present invention, there is provided the apparatus as defined in the seventh aspect, wherein the configuration information includes access address information (url), size information and/or verification information of the service function module application.

According to a tenth aspect of embodiments of the present invention, there is provided an apparatus as described in the seventh aspect, wherein the apparatus further includes:

the extraction unit is used for extracting the public objects from the business function modules of the original objects according to the dependency relationship of the business function modules;

and the construction unit constructs an application program according to the configuration file, the public object and the application programs of the business function modules.

According to an eleventh aspect of an embodiment of the present invention, there is provided an apparatus as in the seventh aspect, wherein the apparatus further includes:

and the modifying unit is used for modifying the packaging identification (packaging ID) of each business function module application program.

According to a twelfth aspect of an embodiment of the present invention, there is provided the apparatus as set forth in the seventh or tenth aspect, wherein the construction unit shells the respective service function module application program and the configuration file, or the respective service function module application program, the configuration file and a common object to construct the application program.

According to a thirteenth aspect of embodiments of the present invention, there is provided a server comprising a processor and a memory for storing processor-executable instructions, the processor implementing the method according to any one of the first to sixth aspects when executing the instructions.

According to a fourteenth aspect of embodiments of the present invention, there is provided a computer readable storage medium having stored thereon a computer program which when executed performs the steps of the method according to any of the first to sixth aspects.

The method has the advantages that hijacking (hook) is carried out on the application programming interface of the original object; extracting relevant configuration information of each business function module application program from the original object to generate a configuration file; and constructing an application program according to the configuration file and the functional modules. Applications compatible with other framework systems can be built by modifying the native plug-in to a lesser extent, thereby reducing modification costs and facilitating backward compatibility.

Specific embodiments of the invention are disclosed in detail below with reference to the following description and drawings, indicating the manner in which the principles of the invention may be employed. It should be understood that the embodiments of the invention are not limited in scope thereby. The embodiments of the invention include many variations, modifications and equivalents within the spirit and scope of the appended claims.

Features that are described and/or illustrated with respect to one embodiment may be used in the same way or in a similar way in one or more other embodiments in combination with or instead of the features of the other embodiments.

It should be emphasized that the term "comprises/comprising" when used herein is taken to specify the presence of stated features, integers, steps or components but does not preclude the presence or addition of one or more other features, integers, steps or components.

Drawings

In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings that are required to be used in the embodiments or the description of the prior art will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments described in the present application, and that other drawings may be obtained according to these drawings without inventive effort to a person skilled in the art.

FIG. 1 is a flowchart of an application program construction method in embodiment 1 of the present application;

FIG. 2 is a schematic diagram of the structure of the primitive object in embodiment 1 of the present application;

FIG. 3 is a schematic diagram of an application program constructed in embodiment 1 of the present application;

FIG. 4 is a flowchart of an application program construction method in embodiment 1 of the present application;

FIG. 5 is a schematic diagram showing the construction of an application program constructing apparatus according to embodiment 2 of the present application;

FIG. 6 is a schematic diagram showing the construction of an application program constructing apparatus according to embodiment 2 of the present application;

fig. 7 is a schematic diagram of the server configuration in embodiment 3 of the present application.

Detailed Description

In order to better understand the technical solutions in the present application, the following description will clearly and completely describe the technical solutions in the embodiments of the present application with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are only some embodiments of the present application, not all embodiments. Based on the embodiments herein, one of ordinary skill in the art will obtain all other embodiments without making any inventive faculty, are intended to fall within the scope of the present application.

In the embodiments of the present application, the terms "first," "second," and the like are used to distinguish between different elements from each other by reference, but do not denote a spatial arrangement or a temporal order of the elements, and the elements should not be limited by the terms. The term "and/or" includes any and all combinations of one or more of the associated listed terms. The terms "comprises," "comprising," "including," "having," and the like, are intended to reference the presence of stated features, elements, components, or groups of components, but do not preclude the presence or addition of one or more other features, elements, components, or groups of components.

In the embodiments herein, the singular forms "a," an, "and" the "include plural referents and are to be construed broadly as" one "or" one type "and not limited to the meaning of" one "or" another; furthermore, the term "comprising" is to be interpreted as including both the singular and the plural, unless the context clearly dictates otherwise. Furthermore, the term "according to" should be understood as "at least partially according to … …", and the term "based on" should be understood as "based at least partially on … …", unless the context clearly indicates otherwise.

In the embodiments of the present application, the interchangeable terms "electronic equipment" and "terminal equipment" include all devices such as mobile telephones, pagers, communicators, electronic organizers, personal Digital Assistants (PDAs), smartphones, portable communicators, tablets, personal computers, servers or the like.

The embodiments of the present application relate to technical terms such as hook, atlas, plugin, gradle, etc., and for convenience of understanding, the following description is provided for simplicity.

Atlas is a containerized framework which is derived in recent years and runs on an Android system, is mainly used for completing the installation, code loading and resource loading of each service module in an operating environment as required, and is a modularized development scheme provided for solving the problems of low iteration efficiency, long fault repair period and the like of a large-scale App method bottleneck at an Android end. The Atlas container technology has the advantages of 1. Low intrusion: the container is based on the replacement of the construction period and the hook of the running period, so that the invasion of the development period code is avoided, and a user can write the service code like writing a common app. 2. Business Bundle isolation: the isolation mechanism in the classloader mode provides a clear boundary for each module, and is convenient for agile iteration of each service. 3. And (3) basic multiplexing: base bundle provides basic middleware and public resources, and service bundle can be directly called without sensing the existence of a framework. 4. Single process: all modules do not independently create independent processes, and are determined by the components themselves, so that memory loss caused by multiple processes is avoided. 5. Loading as required: each module is installed and loaded when needed, so that the speed of starting the whole app is improved. During build-time, the plugin compiles a service layer (Base bundle) into shells of the entire Atlas Apk, each bundle being compiled into an Apk structure and stored in lib/armeabi in the form of native so. Meanwhile, the Application of the construction period substitution Application is the agent Application of the Atlas container.

Gradle is a construction tool, can be used for constructing an installation package apk of an application program, has a plurality of construction plugins in android, and the plugins are programs written by an application program interface conforming to a certain specification, can only run under a system platform specified by the programs and can not be independently run from a specified platform, namely, the plugins can provide dynamic expansion capability, so that the application program loads functions which do not originally belong to the application during running, and can realize dynamic updating and replacement, namely, business modules with certain functions can be packaged into independent plugins in android.

The Android operating system maintains a set of event distribution mechanism, including application triggering events and background logic processing, and is also executed downwards step by step according to the event flow. The hook intercepts and monitors the transmission of events before they are transmitted to the endpoint, like a hook-on-hook event, and is able to handle some own specific events when they are hooked. An application program (app) according to the present embodiment is a file (for example, an installation package file apk) and an application can be installed by executing the file in a corresponding operating system.

Embodiments of the present application are described below with reference to the accompanying drawings.

Example 1

Embodiment 1 of the present application provides a method for constructing an application program, fig. 1 is a flowchart of the method, and as shown in fig. 1, the method includes:

step 101, hijacking (hook) an application programming interface of a native object;

step 102, extracting relevant configuration information of each business function module application program from the original object to generate a configuration file;

and step 103, constructing an application program according to the configuration file and the application programs of the business function modules.

In this embodiment, the native object may be a modular plug-in the android early project build tool, such as an instance app plug-in, where the android early project build tool may be android gradle 3.0 and previous versions, and the embodiment is not limited thereto.

In this embodiment, in step 101, an application programming interface (Application Programming Interface, API) on which a native object depends is obtained, and an API hook is executed, so that an application program can modify a call to a native function into a call (a new function) to steps 102-103 in the present application, specifically, an execution address of the native function can be replaced with an execution address of the new function, and the processing of the API hook can refer to the prior art, for example, a trace function can be designed to trace a target process, a memory space is allocated, and a new function is injected into the space, so that an execution flow of the target process jumps to the injected code function, where, due to the native object being subjected to the hook, a package script under the native architecture can not have any damage in flow.

In this embodiment, in step 102, relevant configuration information of each service function module application program is extracted from a native object, where the object includes code and resources, where the code is a compiled class (class) file, and the resources refer to some help documents, icons, video, audio, and so on.

In this embodiment, fig. 2 is a schematic diagram of a native object structure, as shown in fig. 2, an application program of the native object instance app (i.e. an application program supported by google play service) is constructed as a set of at least two service function module application programs (feature apk), and in the application program of the one instance app, only one basic function apk (base feature apk), and other feature apks on a level with the basic function apk, where the base feature may include some public spaces or basic information, etc., and the other feature apk may implement different service functions, for example, for some e-commerce instance, it may be constructed to include detail feature apk, shopping cart feature apk, order feature apk, user feature apk, etc.; in step 102, a manifest may be invoked, the code of each feature apk parsed, and relevant configuration information for each feature apk extracted therefrom, including access address information (url), size information, and/or verification information for the business function module application.

In this embodiment, in step 102, a configuration file is generated according to each extracted relevant configuration information, for example, the relevant configuration information may be written in a property file to obtain the configuration file, and in order to distinguish the configuration information of different feature apks, the configuration file further includes a feature apk identifier, for example, N feature apks in total, where each feature apk extracts the configuration information as feature apk: URL, SIZE, check info, the configuration file may be written with the following information:

Feature apk 1：URL,SIZE,check info

Feature apk 2：URL,SIZE,check info

……

Feature apk N：URL,SIZE,check info

in this embodiment, after the feature apk is parsed by invoking the manifest, the feature apk needs to be repackaged (package) after the configuration information is extracted, and since the resource segment of the feature apk under the native object is 0x8000000, if the feature apk is still packed by using the native package id (80), a conflict may occur under other frameworks (for example, atlas), so the method may further include: the package identification (packageID) of each business function module application is modified, for example, the resource segment can be modified to 0x7f00000, where 7f is the packageID. In this embodiment, the packageID may be specified by an android package tool (Android Asset Packaging Tool, AAPT), and reference may be made specifically to the prior art.

In this embodiment, in step 103, an application is constructed according to the configuration file and the respective function module applications. The base feature apk and the feature apk supported by the native architecture (google play service) belong to a flat class, and are packaged together to generate an instance app, in step 103, the base feature apk may be regarded as a shell (container) of the application program, that is, the base feature apk and the configuration file generated by repackaging the respective service function modules are directly shelled to construct the application program, where the processing of the shelled application program may be implemented by generating a dex file, a specific method for generating dex may refer to the prior art, the constructed application program is an application program that may be supported by atlas, a structure of the atlas apk is shown in fig. 3, each service function module is compiled into a structure of apk and stored in lib/anabi in a form of so, and a shell dex is added, and specific details may refer to the prior art and will not be repeated herein.

By the construction method in the embodiment, the application program compatible with other frame systems can be constructed by modifying the original plug-in to a small extent, so that the modification cost is reduced, and backward compatibility is easy.

Fig. 4 is a flowchart of a method for constructing an application program in the present embodiment, as shown in fig. 4, the method includes:

step 401, hijack (hook) the application programming interface of the native object;

step 402, extracting a common object from each business function module of the original object according to the dependency relationship of each business function module;

step 403, extracting relevant configuration information of each service function module application program from the original object to generate a configuration file;

step 404, constructing an application program according to the configuration file, the common object, and the application programs of the service function modules.

In this embodiment, the specific implementation of step 401 may refer to step 301, which is not described herein.

In this embodiment, in order to save space of an application program and improve coding efficiency, in step 402, a common object is extracted from each feature apk of a native object according to a dependency relationship of each feature apk, in this embodiment, the common object may include a code or a resource file common to each feature apk, and the common object may be a code or a resource file common to at least two feature apks, taking detail feature apk and shopping cart feature apk as examples, including the following common objects: an object of operation (here, merely an example, and not limited to the common object) is slid, wherein the common object can be split from the respective feature apks to save space of the respective feature apks.

In this embodiment, the specific implementation manner of extracting the relevant configuration information of the application program of each service function module in step 403 may refer to step 302, and when a configuration file is generated, in addition to the relevant configuration information, the dependency relationship between each feature apk and the common object extracted in step 402 may also be included, for example, the detail feature apk is recorded in the configuration file and depends on the sliding operation object, so that when the later application program is loaded, each feature apk may be loaded completely according to the configuration file, and the complete function of each feature apk may be implemented.

In this embodiment, in step 404, the common object may be packaged under the shell at the same time on the basis of step 303, so as to construct a compatible application, and the specific packaging manner may refer to the prior art, which is not described herein.

Through the above embodiment, the native official package script can be not destroyed in any flow based on the hook mode, in addition, the above construction method in the present embodiment is suitable for developing internationalized product application programs, which can allow a set of engineering structures to construct various different types of expression forms, that is, through the construction method in the above embodiment, application programs compatible by other framework systems can be constructed through carrying out minor modification on the native plug-in, thereby reducing modification cost and being easy to be backwards compatible.

Example 2

Embodiment 2 of the present invention provides an application program construction device, and since the principle of solving the problem by the device is similar to that of embodiment 1, the specific implementation of the device can refer to the implementation of the method of embodiment 1, and the description is not repeated. Fig. 5 is a schematic view of the apparatus, as shown in fig. 5, including:

a hijacking unit 501 for hijacking (hook) an application programming interface of a native object;

a generating unit 502, configured to extract relevant configuration information of each service function module application program from the native object, and generate a configuration file;

a construction unit 503, configured to construct an application program according to the configuration file and the respective functional modules.

In this embodiment, the hijacking unit 501, the generating unit 502, and the constructing unit 503 may refer to steps 101 to 103 of embodiment 1, and the repetition is not repeated.

In this embodiment, the object includes code and resources, and the configuration information includes access address information (url), size information, and/or verification information of the service function module application.

In this embodiment, the apparatus further includes:

a modification unit (optional, not shown) is configured to modify the package identifier (package id) of each service function module application program, and the specific implementation manner of this modification unit may refer to embodiment 1 and will not be described herein.

Fig. 6 is a schematic diagram of another implementation of the application program construction apparatus in this embodiment, as shown in fig. 6, where the apparatus includes:

a hijacking unit 601 for hijacking (hook) an application programming interface of a native object;

an extracting unit 602, configured to extract a common object from each service function module of the native object according to the dependency relationship of each service function module;

a generating unit 603, configured to extract relevant configuration information of each service function module application program from the native object, and generate a configuration file;

a construction unit 604, configured to construct an application program according to the configuration file, the common object, and the respective functional modules.

In this embodiment, the specific implementation manners of the hijacking unit 601, the extracting unit 602, the generating unit 603, and the constructing unit 604 may refer to steps 401-404 of embodiment 1, and the repetition is not repeated.

In this embodiment, the apparatus further includes:

Through the above embodiment, the native official package script can be not destroyed in any flow based on the hook mode, in addition, the above construction method in the present embodiment is suitable for developing internationalized product application programs, which can allow a set of engineering structures to construct various different types of expression forms, that is, through the construction device in the above embodiment, application programs compatible by other framework systems can be constructed through carrying out minor modification on the native plug-in, thereby reducing modification cost and being easy to be backwards compatible.

Example 3

Embodiment 3 also provides a server, fig. 7 is a schematic diagram of the server, and as shown in fig. 7, the server includes a central processor 701 and a memory 702; the memory 702 is coupled to the central processor 701. The figure is exemplary; other types of structures may also be used in addition to or in place of the structures to implement telecommunications functions or other functions.

In this embodiment, the central processor 701 may be configured to perform: hijack (hook) the application programming interface of the native object; extracting relevant configuration information of each business function module application program from the original object to generate a configuration file; and constructing an application program according to the configuration file and the application programs of the functional modules.

In this embodiment, the central processor 701 may be configured to perform: extracting a public object from each business function module of the original object according to the dependency relationship of each business function module; and constructing an application program according to the configuration file, the common object and the application programs of the functional modules.

In this embodiment, the central processor 701 may be configured to perform: the package identification (packageID) of each business function module application is modified.

In this embodiment, the central processor 701 may be configured to perform: the respective function module application and the configuration file, or the respective function module application, the configuration file and the common object are shelled to construct the application.

In this embodiment, the specific implementation of the cpu 701 can refer to embodiment 1, and will not be described herein.

As shown in fig. 7, the central processor 701, sometimes also referred to as a controller or operational control, may include a microprocessor or other processor device and/or logic device, with the central processor 701 receiving inputs and controlling the operation of the various components of the device 600.

In this embodiment, the memory 702 may be, for example, one or more of a buffer, a flash memory, a hard drive, a removable media, a volatile memory, a non-volatile memory, or other suitable device. And the central processor 701 can execute the program stored in the memory 702 to realize information storage or processing, etc. The function of the other components is similar to that of the prior art and will not be described in detail here. The various components of the apparatus 700 may be implemented by dedicated hardware, firmware, software, or combinations thereof without departing from the scope of the invention.

In this embodiment, there is also provided a terminal device (not shown) including the

apparatus

500 or 600, or the

apparatus

500 or 600 may be a chip connected to a central processor included in the terminal device, and the functions of the

apparatus

500 or 600 are implemented by controlling the central processor included in the apparatus, and the terminal device may further include an input unit, a display, a power source, a communication module (not shown), and the like, and the structure thereof may refer to the prior art, and this embodiment is not limited thereto.

In this embodiment, there is also provided a build plug-in android, which is used to implement the application build method in embodiment 1.

The embodiment of the present invention also provides a computer-readable program, wherein the program, when executed in an application program construction apparatus, causes a computer to execute the application program construction method as in embodiment 1 above in the application program construction apparatus.

The program may be software that can be run in the terminal device. For example: and application software such as mobile phone panning, payment, or browser.

The embodiment of the present invention also provides a computer-readable storage medium having stored thereon a computer program which, when executed, implements the application program construction method as in embodiment 1 above.

Although the present application provides method operational steps as described in the examples or flowcharts, more or fewer operational steps may be included based on conventional or non-inventive labor. The order of steps recited in the embodiments is merely one way of performing the order of steps and does not represent a unique order of execution. When implemented by an actual device or client product, the instructions may be executed sequentially or in parallel (e.g., in a parallel processor or multi-threaded processing environment) as shown in the embodiments or figures.

The apparatus or module set forth in the above embodiments may be implemented in particular by a computer chip or entity, or by a product having a certain function. For convenience of description, the above devices are described as being functionally divided into various modules, respectively. The functions of the various modules may be implemented in the same piece or pieces of software and/or hardware when implementing the present application. Of course, a module that implements a certain function may be implemented by a plurality of sub-modules or a combination of sub-units.

The methods, apparatus or modules described herein may be implemented in computer readable program code means and in any suitable manner, e.g., the controller may take the form of, for example, a microprocessor or processor and a computer readable medium storing computer readable program code (e.g., software or firmware) executable by the (micro) processor, logic gates, switches, application specific integrated circuits (Application Specific Integrated Circuit, ASIC), programmable logic controllers and embedded microcontrollers, examples of which include, but are not limited to, the following microcontrollers: ARC 625D, atmel AT91SAM, microchip PIC18F26K20, and Silicone Labs C8051F320, the memory controller may also be implemented as part of the control logic of the memory. Those skilled in the art will also appreciate that, in addition to implementing the controller in a pure computer readable program code, it is well possible to implement the same functionality by logically programming the method steps such that the controller is in the form of logic gates, switches, application specific integrated circuits, programmable logic controllers, embedded microcontrollers, etc. Such a controller can be regarded as a hardware component, and means for implementing various functions included therein can also be regarded as a structure within the hardware component. Or even means for achieving the various functions may be regarded as either software modules implementing the methods or structures within hardware components.

Some of the modules of the apparatus described herein may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, classes, etc. that perform particular tasks or implement particular abstract data types. The application may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.

From the description of the embodiments above, it will be apparent to those skilled in the art that the present application may be implemented in software plus necessary hardware. Based on such understanding, the technical solution of the present application may be embodied essentially or in a part contributing to the prior art in the form of a software product, or may be embodied in the implementation of data migration. The computer software product may be stored on a storage medium, such as ROM/RAM, magnetic disk, optical disk, etc., comprising instructions for causing a computer device (which may be a personal computer, mobile terminal, server, or network device, etc.) to perform the methods described in various embodiments or portions of embodiments herein.

Various embodiments in this specification are described in a progressive manner, and identical or similar parts are all provided for each embodiment, each embodiment focusing on differences from other embodiments. All or portions of the present application can be used in a number of general purpose or special purpose computer system environments or configurations. For example: personal computers, server computers, hand-held or portable devices, tablet devices, mobile communication terminals, multiprocessor systems, microprocessor-based systems, programmable electronic devices, network PCs, minicomputers, mainframe computers, distributed computing environments that include any of the above systems or devices, and the like.

Although the present application has been described by way of example, those of ordinary skill in the art will recognize that there are many variations and modifications of the present application without departing from the spirit of the present application, and it is intended that the appended claims encompass such variations and modifications without departing from the spirit of the present application.

Claims

1. An application program construction method, wherein the method comprises:

hijacking an application programming interface of a primary object; the native object is a modular plug-in the project build tool, the native object comprising code and resources;

2. The method of claim 1, wherein the configuration information includes access address information, size information, and/or verification information of a service function module application.

3. The method of claim 1, wherein the method further comprises:

extracting a public object from each business function module of the original object according to the dependency relationship of each business function module;

4. The method of claim 1, wherein the method further comprises:

and modifying the packing identification of each business function module application program.

5. A method according to claim 1 or 3, wherein building an application comprises:

6. An application build apparatus, wherein the apparatus comprises:

the hijacking unit is used for hijacking the application programming interface of the original object; the native object is a modular plug-in the project build tool, the native object comprising code and resources;

7. The apparatus of claim 6, wherein the configuration information comprises access address information, size information, and/or verification information of a business function module application.

8. The apparatus of claim 6, wherein the apparatus further comprises:

9. The apparatus of claim 6, wherein the apparatus further comprises:

and the modifying unit is used for modifying the packing identification of each business function module application program.

10. The apparatus according to claim 6 or 8, wherein the construction unit shells the respective business function module application programs and the configuration file, or the respective business function module application programs, the configuration file and a common object to construct the application programs.

11. A server comprising a processor and a memory for storing processor-executable instructions, the processor implementing the method of any one of claims 1 to 5 when executing the instructions.

12. A computer readable storage medium having stored thereon a computer program which when executed performs the steps of the method of any of claims 1 to 5.