US20190004828A1

US20190004828A1 - Application loading method, user terminal, and storage medium

Info

Publication number: US20190004828A1
Application number: US16/023,768
Authority: US
Inventors: Yinfeng Huang
Original assignee: Guangzhou Uc Network Technology Co Ltd
Current assignee: Alibaba Group Holding Ltd
Priority date: 2017-06-29
Filing date: 2018-06-29
Publication date: 2019-01-03
Also published as: RU2018108631A; US10860337B2; US20190004829A1; CN107329788A

Abstract

An application loading method, a user terminal and a storage medium are provided. The method includes in response to a function enabling instruction, matching a corresponding independent functional component of an application. The application is packaged in advance to include a plurality of different functional components based on differences in functions to be implemented, and the plurality of different functional components include the independent functional component. The method also includes obtaining an executable file corresponding to the independent functional component. Further, the method includes loading the executable file corresponding to the independent functional component.

Description

CROSS-REFERENCES TO RELATED APPLICATIONS

This application claims the priority of Chinese patent application No. 201710515088.4, filed on Jun. 30, 2017, the entirety of which is incorporated herein by reference.

FIELD OF THE DISCLOSURE

The present disclosure generally relates to the field of internet technology and, more particularly, relates to an application loading method, and a user terminal and a storage medium thereof.

BACKGROUND

Applications are software that is compiled to satisfy user application purposes. As the main body of the Internet for providing services to the users, the operation of applications will directly affect the user's experience of using Internet services. As the functions implemented by the applications become more and more diverse and the provided services become more and more intelligent, codes corresponding to applications become more and more complicated. As a result, the application loading process is slow and error-prone, takes up a large amount of storage space, and takes a long time. The disclosed methods and device structures are directed to solve one or more problems set forth above and other problems.

BRIEF SUMMARY OF THE DISCLOSURE

One aspect of the present disclosure includes an application loading method applied to a user terminal. The method includes in response to a function enabling instruction, matching a corresponding independent functional component of an application. The application is packaged in advance to include a plurality of different functional components based on differences in functions to be implemented, and the plurality of different functional components include the independent functional component. The method also includes obtaining an executable file corresponding to the independent functional component. Further, the method includes loading the executable file corresponding to the independent functional component.
Another aspect of the present disclosure includes a user terminal. The user terminal includes a memory, configured to store program instructions for an application loading method, and a processor, coupled to the memory and, when executing the program instructions, configured to: in response to a function enabling instruction, match a corresponding independent functional component of an application, wherein the application is packaged in advance to include a plurality of different functional components based on differences in functions to be implemented, and the plurality of different functional components include the independent functional component; obtain an executable file corresponding to the independent functional component; and load the executable file corresponding to the independent functional component.
Another aspect of the present disclosure includes a non-transitory computer-readable storage medium containing computer-executable program instructions for, when executed by a processor, performing an application loading method. The method includes: in response to a function enabling instruction, matching a corresponding independent functional component of an application, wherein the application is packaged in advance to include a plurality of different functional components based on differences in functions to be implemented, and the plurality of different functional components include the independent functional component; obtaining an executable file corresponding to the independent functional component; and loading the executable file corresponding to the independent functional component.
Other aspects of the present disclosure can be understood by those skilled in the art in light of the description, the claims, and the drawings of the present disclosure.

BRIEF DESCRIPTION OF THE DRAWINGS

To more clearly illustrate the embodiments of the present disclosure, the drawings will be briefly described below. The drawings in the following description are certain embodiments of the present disclosure, and other drawings may be obtained by a person of ordinary skill in the art in view of the drawings provided without creative efforts.

FIG. 1 illustrates a schematic block diagram of a user terminal consistent with various disclosed embodiments of the present disclosure;

FIG. 2 illustrates a flowchart of an application loading method consistent with various disclosed embodiments of the present disclosure;

FIG. 3 illustrates a sub-flowchart of S103 consistent with various disclosed embodiments of the present disclosure;

FIG. 4 illustrates another sub-flowchart of S103 consistent with various disclosed embodiments of the present disclosure;

FIG. 5 illustrates a schematic diagram of different functional components of an application loading device consistent with various disclosed embodiments of the present disclosure;

FIG. 6 illustrates a schematic diagram of functional sub-components of a matching component consistent with various disclosed embodiments of the present disclosure; and

FIG. 7 illustrates another schematic diagram of functional sub-components of a matching component consistent with various disclosed embodiments of the present disclosure.

References in the drawings: 100-user terminal; 111-memory; 112-memory controller; 113-processor; 114-peripheral interface; 115-display unit; 116-input/output unit; 200-application loading device; 201-obtaining component; 202-matching component; 2021-querying sub-component; 2022-acquiring sub-component; 2023-determination sub-component; 203-first loading component; 204-acquiring component; and 205-second loading component.

DETAILED DESCRIPTION

Reference will now be made in detail to exemplary embodiments of the disclosure, which are illustrated in the accompanying drawings. The described embodiments are merely some but not all of the embodiments of the present disclosure. The components, which are generally described and illustrated in the figures herein, in the disclosed embodiments of the present disclosure may be arranged and designed in a wide variety of different configurations. Thus, the following detailed description of embodiments of the present disclosure provided in the drawings is not intended to limit the scope of the disclosure as claimed, but is merely representative of selected embodiments of the present disclosure. All other embodiments obtained by those skilled in the art based on the embodiments of the present disclosure without any creative work fall within the protection scope of the present disclosure.
Wherever possible, the same or similar reference numbers and letters will be used throughout the drawings to refer to the same or the alike parts. Therefore, once an item is defined in one figure, the item does not need to be further defined and explained in subsequent figures. Meanwhile, in the description of the present disclosure, the terms “first”, “second”, etc., are merely used to distinguish the description and cannot be interpreted as indicating or suggesting relative importance.
FIG. 1 illustrates a schematic block diagram of a user terminal 100 consistent with various disclosed embodiments of the present disclosure. The user terminal 100 may be, but not limited to, a mobile terminal device, and a computer, for example, may include a smart phone, a tablet computer, a laptop portable computer, a vehicle-mounted computer, a personal digital assistant (PDA), a desktop computer, etc. The user terminal 100 may include an application loading device 200, a memory 111, a memory controller 112, a processor 113, a peripheral interface 114, a display unit 115, and an input/output unit 116.
The memory 111, the memory controller 112, the processor 113, the peripheral interface 114, the display unit 115, and the input/output unit 116 may be directly or indirectly electrically connected to each other to implement data transmission or exchange. For example, these elements may be electrically connected to each other through one or more communication buses or signal lines. The application loading device 200 may include at least one software functional component that can be stored in the memory 111 in the form of software or firmware, or may be firmed in an operating system (OS) of the user terminal 100. The processor 113 may be configured to execute an executable component stored in the memory 111, e.g., the software functional component included in the application loading device 200, and a computer program, etc.
The memory 111 may be, but not limited to, a random-access memory (RAM), a read-only memory (ROM), a programmable read-only memory (PROM), an erasable programmable read-only memory (EPROM), and an electrical erasable programmable read-only memory (EEPROM), etc. Further, the memory 111 may be used for storing programs (including an operating system program), and the processor 113 may execute the programs after receiving the execution instructions. Access to the memory 111 by the processor 113 and other possible components may be performed under the control of the memory controller 112.
The processor 113 may be an integrated circuit chip with signal processing capabilities. The foregoing processor 113 may be a general-purpose processor, including a central processing unit (CPU), a network processor (NP), etc. In another embodiment, the processor 113 may be a digital signal processor (DSP), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), etc. In certain embodiments, the processor 113 may be other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, that are capable of implementing or executing the methods, steps, and logic blocks disclosed in the embodiments of the present disclosure. The general-purpose processor may be a microprocessor, or the processor 113 may be any conventional processor, etc.
The peripheral interface 114 may couple various input/output devices (e.g., the display unit 115, the input/output unit 116) to the processor 113 and the memory 111. In one embodiment, the peripheral interface 114, the processor 113, and the memory controller 112 may be implemented in a single chip. In another embodiment, the peripheral interface 114, the processor 113, and the memory controller 112 may be implemented by independent chips, respectively.
The display unit 115 may provide an interactive interface (e.g., a user operation interface) between the user terminal 100 and the user, or may be used to display image data. In one embodiment, the display unit 115 may be a liquid crystal display or a touch display. If the display unit 115 is a touch display, the display unit may be a capacitive touch screen or a resistive touch screen that supports single-point and multi-touch operations. Supporting single-point and multi-touch operations may refer to that the touch display can sense touch operations generated from one or more locations on the touch display and pass the sensed touch operations to the processor 113 for calculating and processing.
The input/output unit 116 may be configured to provide input data by a user to implement user interaction with the user terminal 100. The input/output unit 116 may be, but not limited to, a virtual keyboard, a voice input circuit, etc.

Exemplary Embodiment 1

FIG. 2 illustrates a flowchart of an application loading method consistent with various disclosed embodiments of the present disclosure. Referring to FIG. 2, the application loading method may be applied to the user terminal 100. The method may include the following.
In S101: When detecting that the application is started, obtaining an executable file corresponding to a basic functional component.
In one embodiment, the application may be packaged in advance to include a plurality of different functional components based on differences in functions to be implemented, and may be stored in the memory 111 of the user terminal 100. Optionally, the application may be stored in an ‘asset’ directory. Further, the different functional components may include the basic functional component. The basic functional component may be a functional component that implements the basic functions of the application, that is, the functional component that has to be loaded after the application is started, e.g., a functional component for displaying the initial interface. The executable file may be a file that can be loaded and executed by the operating system. For example, the executable file corresponding to the Android operating system may be a file having a DEX format. The executable file corresponding to the basic functional component may be obtained by extracting the functional component in the application. Optionally, the basic functional component of the application may be stored in the user terminal 100 after being extracted by the user terminal 100 to facilitate to be obtained directly without extracting the basic functional component when the application is started in a following time. For example, the basic functional component in the ‘asset’ directory may be extracted to the ‘application’ directory. When having to be obtained in a following time, the executable file corresponding to the basic functional component may be obtained directly from the extracted basic functional component in the ‘application’ directory.
In S102: Loading the executable file corresponding to the basic functional component into the memory 111 of the user terminal 100.
In one embodiment, the obtained executable file corresponding to the basic functional component may be loaded into a temporary memory in the memory 111, and component contents corresponding to the basic functional component may be loaded into the temporary memory, to execute the basic functions corresponding to the basic functional component and to implement the application's operation.
In S103: In response to the function enabling instruction, matching corresponding independent functional component of the application.
In one embodiment, the application may be packaged in advance to include a plurality of different functional components based on differences in functions to be implemented, and the plurality of different functional components may further include a plurality of independent functional components. After the application is started, the independent functional component may be loaded and executed to implement the function corresponding to the independent functional component. The independent functional component may be loaded and executed when the corresponding function enabling instruction is triggered, to reduce unnecessary storage space usage. Taking ‘Taobao’ client as an example, the ‘Taobao’ client may include product search function, communication with seller function, payment function, and other functions. When the ‘Taobao’ client has to implement one of the above functions, the independent functional component corresponding to the one function may have to be loaded and executed. For example, to implement the product search function, a search function component may be loaded and executed. To implement the communication with seller function, a chat function component may be loaded and executed. To implement the payment function, a payment function component may be loaded and executed. Using any one of the independent functional components may have to be first matched to the one independent functional component, while matching the independent functional component may need the corresponding function enabling instruction to be triggered.
Optionally, the user may trigger the function enabling instruction through the input/output unit 116 according to use demand. For example, when the user's use demand is to implement the product search function, a search enabling instruction may be triggered by clicking a search box through the input/output unit 116, and the user terminal 100 may match the search function component according to the obtained triggered search enabling instruction. When the user needs to communicate with a seller, a communication enabling instruction may be triggered after receiving an operation of user selecting seller through the input/output unit 116, and the user terminal 100 may match the chat function component according to the communication enabling instruction. When the user needs to make a payment, a payment enabling instruction may be triggered after obtaining fingerprint, or password, etc., through the input/output unit 116, and the user terminal 100 may match the payment function component according to the obtained payment enabling instruction. After obtaining the function enabling instruction, the user terminal 100 may match corresponding independent functional component according to a first function that needs to be implemented and corresponding to the obtained function enabling instruction. Referring to FIG. 3, the method in S103 may include the following.
In S10311: Querying whether the extracted independent functional component has an executable file corresponding to the first function.
In one embodiment, the independent functional component may include the corresponding executable file. The independent functional component may be extracted to obtain the corresponding executable file. Loading and executing the independent functional component may include loading and executing the corresponding executable file. When one independent functional component of an application is used for the first time, the corresponding independent functional component may have to be obtained from the application, and may be extracted to obtain the corresponding executable file to be stored. Therefore, when the user terminal 100 obtains the function enabling instruction corresponding to the first function, it may be first queried that whether the extracted independent functional component has the executable file corresponding to the first function, to reduce duplicated work and occupying extra storage space. If the extracted independent functional component does not have the executable file corresponding to the first function, the process may proceed to S10312; if the extracted independent functional component has the executable file corresponding to the first function, the process may proceed to S10313.
In S10312: Obtaining an unextracted independent functional component corresponding to the first function in the application.
In one embodiment, the program file of the application may be accessed from the memory 111 according to the directory path of storing the application. The program file may include the entire independent functional components and basic functional component, which may not be extracted. The independent functional component corresponding to executing the first function may be obtained from the unextracted independent functional components.
In S10313: Obtaining the extracted independent functional component.
In another embodiment, referring to FIG. 4, the method in S103 may include the following.
In S10321: Querying whether the extracted independent functional component has an executable file corresponding to the first function. When the extracted independent functional component has the executable file corresponding to the first function, the process may proceed to S10322; when the extracted independent functional component does not have the executable file corresponding to the first function, the process may proceed to S10324.
In S10322: Determining whether the executable file corresponding to the first function is valid. Optionally, first MD5 codes of the executable file corresponding to the first function may be calculated by using an information digest algorithm. The first MD5 codes may be compared with second MD5 codes of the executable file, which are calculated and stored when extracting the independent functional component corresponding to the first function, to verify whether the extracted independent functional component is tampered when being stored. Thus, the tampered application may be prevented from running to reduce the user's experience. When the executable file corresponding to the first function is valid, the process may proceed to S10323; when the executable file corresponding to the first function is invalid, the process may proceed to S10324.
In S10323: Obtaining the extracted independent functional component.
In S10324: Obtaining the unextracted independent functional component corresponding to the first function in the application.
In S104: Obtaining the executable file corresponding to the independent functional component.
In one embodiment, the executable file may be obtained from the independent functional component obtained in S103. The user terminal 100 may not directly obtain the corresponding executable file from the unextracted independent functional component, but may obtain the corresponding executable file from the extracted independent functional component. Optionally, when the independent functional component obtained in S103 is not extracted, the unextracted independent functional component corresponding to the first function may be extracted to obtain the executable file. When the independent functional component obtained in S103 has been extracted, the executable file corresponding to the first function may be obtained from the extracted independent functional component. The executable file may be a file that can be loaded and executed by the operating system. For example, the executable file corresponding to the Android operating system may be a file having a DEX format.
In S105: Loading the executable file corresponding to the independent functional component.
In one embodiment, the user terminal 100 may execute the first function corresponding to the independent functional component after loading the executable file.
Optionally, the executable file may be loaded into the temporary memory to facilitate immediate execution. For example, the executable file corresponding to the independent functional component may be incorporated into the executable file corresponding to the basic functional component. The executable file corresponding to the basic functional component may have been loaded into the temporary memory to be executed when the application is started. Therefore, the executable file corresponding to the independent functional component may be incorporated into the executable file corresponding to the basic functional component to be loaded.
In S106: Acquiring component contents corresponding to the independent functional component.
In one embodiment, after the independent functional component is extracted, the corresponding executable file and component contents may be obtained. The executable file and component contents obtained by extracting the independent functional component every time may replace the executable file and component contents obtained from last extraction. After loading the executable file, the corresponding component contents may be obtained directly from the corresponding extracted independent functional component. The component contents may be the material data required for the executable file to execute the first function. For example, when the executable file in the Taobao client executes the function of communication with the merchant, the component contents may be, but not limited to image material of the dialog box, the material displayed on the interface, etc.
In S107: Loading the component contents.
In one embodiment, the component contents may be loaded into the temporary memory to facilitate invoking the component contents when executing the executable file to present the function implementation interface to the user through the display unit 115.

Exemplary Embodiment 2

FIG. 5 illustrates a schematic diagram of different functional components of an application loading device 200 consistent with various disclosed embodiments of the present disclosure. The application loading device 200 may include an obtaining component 201, a matching component 202, a first loading component 203, an acquiring component 204, and a second loading component 205.
The obtaining component 201 may be configured to obtain the executable file corresponding to the basic functional component when detecting that the application is started. In one embodiment, the method in S101 may be executed by the obtaining component 201.
The first loading component 203 may be configured to load the executable file corresponding to the basic functional component into the memory 111 of the user terminal 100. In one embodiment, the method in S102 may be executed by the first loading component 203.
The matching component 202 may be configured to in response to the function enabling instruction, match the corresponding independent functional component of the application.
In one embodiment, the application may be packaged in advance to include a plurality of different functional components based on differences in functions to be implemented, and the plurality of different functional components may further include a plurality of independent functional components. The method in S103 may be executed by the matching component 202. After the application is started, a plurality of independent functions may be implemented, and each independent function may correspond to one independent functional component. The one independent functional component may be loaded and executed when the corresponding function is used, to reduce unnecessary storage space usage. Optionally, when the user needs to enable an independent function in the application, a function enabling instruction corresponding to the independent function may be generated through the input/output unit 116. For example, when the user needs to use the product search of the Taobao client', the user may trigger the search enabling instruction by clicking on the search box. After obtaining the function enabling instruction, the user terminal 100 may match the corresponding independent functional component according to the first function that needs to be implemented and corresponding to the obtained function enabling instruction. Referring to FIG. 6, the matching component 202 may include the following sub-components: a query sub-component 2021 and an acquiring sub-component 2022.
The query sub-component 2021 may be configured to query whether the extracted independent functional component has an executable file corresponding to the first function. In one embodiment, the method in S10311 may be executed by the query sub-component 2021. In another embodiment, the method in S10321 may be executed by the query sub-component 2021.
The acquiring sub-component 2022 may be configured to acquire the unextracted independent functional component corresponding to the first function in the application, and further to acquire the extracted independent functional component.
In one embodiment, the methods in both S10312 and S10313 may be executed by the acquiring sub-component 2022. Optionally, if the extracted independent functional component does not have the executable file corresponding to the first function, the method in S10312 may be executed. If the extracted independent functional component has the executable file corresponding to the first function, the method in S10313 may be executed.
In another embodiment, the methods in both S10323 and S10324 may be executed by the acquiring sub-component 2022. Optionally, when the extracted independent functional component has the executable file corresponding to the first function, and the executable file corresponding to the first function is valid, the acquiring sub-component 2022 may execute the method in S10323. When the extracted independent functional component does not have the executable file corresponding to the first function, or the executable file corresponding to the first function is invalid, the acquiring sub-component 2022 may execute the method in S10324.
In certain embodiments, referring to FIG. 7, the matching component 202 may further include a determination sub-component 2023. The determination sub-component 2023 may be configured to determine whether the executable file corresponding to the first function is valid. The method in S10322 may be executed by the determination sub-component 2023.
The obtaining component 201 may be further configured to obtain the executable file corresponding to the independent functional component. In one embodiment, the method in
S104 may be executed by the obtaining component 201. Optionally, the executable file may be obtained by extracting the unextracted independent functional component corresponding to the first function; or the executable file corresponding to the first function may be obtained from the extracted independent functional component.
The first loading component 203 may be further configured to load the executable file corresponding to the independent functional component. In one embodiment, the method in S105 may be executed by the first loading component 203. Optionally, the method in S105 may be executed by incorporating the executable file corresponding to the independent functional component into the executable file corresponding to the basic functional component.
The acquiring component 204 may be configured to acquire the component contents corresponding to the independent functional component. In one embodiment, the method in S106 may be executed by the acquiring component 204.
The second loading component 205 may be configured to load the component contents. In one embodiment, the method in S107 may be executed by the second loading component 205.
Accordingly, the present disclosure provides an application loading method, device, and user terminal. The application loading method may be applied to the user terminal.
The method may include in response to the function enabling instruction, matching the corresponding independent functional component of the application. The application may be packaged in advance to include a plurality of different functional components based on differences in functions to be implemented, and the plurality of different functional components may include a plurality of independent functional components. The method may also include obtaining the executable file corresponding to the independent functional component; and loading the executable file corresponding to the independent functional component. The executable file corresponding to the function that needs to be used may be loaded, such that the application loading may be more flexible and faster, and the application may be prevented from occupying a lot of temporary memory space for a long time. Therefore, the usage of the user terminal's storage space may increase, and the user's experience may be improved.
In the disclosed embodiments of the present disclosure, the disclosed device and method may be implemented in other manners. The device embodiments described above are merely illustrative, and for example, the flowcharts and block diagrams in the drawings may illustrate architecture, function and operation that are implemented according to the device, method, and computer program products consistent with various disclosed embodiments of the present disclosure. Each box in the flowchart or block diagram may represent a component, a program section, or a portion of codes, which may include one or more executable instructions for implementing specified logical functions. In some alternative implementations, the functions noted in the boxes may occur in an order different from those noted in the figures. For example, two consecutive boxes may actually be executed substantially in parallel, or sometime, may be executed in a reverse order depending on the involved functions. Each box in the block diagrams and/or flowcharts, and combinations of boxes in the block diagrams and/or flowcharts, may be implemented by special purpose hardware-based systems that execute the specified functions or actions, or may be implemented by a combination of dedicated hardware and computer instructions.
In addition, respective functional components in various embodiments of the present disclosure may be integrated together to form an independent part, or each component may exist alone, or two or more components may be integrated to form an independent part.
When the integrated units are realized through software functional units, and are sold and used as independent products, the integrated units may be stored on computer readable storage media. Based on this understanding, all or a part of the generic principles or the scope of the disclosure may be embodied in software products. The computer software products may be stored in storage media and may include a plurality of commands to instruct a computer system (such as personal computer, server, network system, etc.) or a processor to execute all or a part of the procedures described in various embodiments consistent with the present disclosure. The storage media may include U disk, mobile hard disk, read-only memory (ROM), random access memory (RAM), magnetic disk, optical disk, or any other appropriate media that can be used to store program code.
In the disclosed embodiments of the present disclosure, terms ‘first’, ‘second’, etc., are merely used for descriptive purposes to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply that these entities or operations have any such actual relationship or order. Further, terms ‘include’, ‘including’, or any other variations thereof are intended to cover non-exclusive inclusions, such that a process, method, article, or device that includes a series of elements includes not merely those elements, but also includes other elements that are not explicitly listed, or further includes elements that are inherent to such process, method, article, or apparatus. In the case of no more limitation, the element defined by the sentence ‘includes a . . . ‘does not exclude that additional same elements exist in the process, method, article, or apparatus.
The foregoing descriptions are merely preferred embodiments of the present disclosure and are not intended to limit the scope of the present disclosure. For those skilled in the art, the present disclosure may have various changes and modifications. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present disclosure shall fall within the protection scope of the present disclosure. The same or similar numerals and letters refer to similar items in the following figures, and therefore, once an item is defined in one figure, it may not need to be further defined and explained in subsequent figures.
The above detailed descriptions only illustrate certain exemplary embodiments of the present disclosure, and are not intended to limit the scope of the present disclosure. Those skilled in the art can understand the specification as whole and technical features in the various embodiments can be combined into other embodiments understandable to those persons of ordinary skill in the art. Any equivalent or modification thereof, without departing from the spirit and principle of the present disclosure, falls within the true scope of the present disclosure.

Claims

What is claimed is:

1. An application loading method applied to a user terminal, the method comprising:

in response to a function enabling instruction, matching a corresponding independent functional component of an application, wherein the application is packaged in advance to include a plurality of different functional components based on differences in functions to be implemented, and the plurality of different functional components include the independent functional component;

obtaining an executable file corresponding to the independent functional component; and

loading the executable file corresponding to the independent functional component.

2. The method according to claim 1, wherein:

the plurality of different functional components further include a basic functional component, wherein the method further includes:

when detecting that the application is started, obtaining an executable file corresponding to the basic functional component, and

loading the executable file corresponding to the basic functional component into a memory of the user terminal.

3. The method according to claim 2, wherein loading the executable file corresponding to the independent functional component includes:

incorporating the executable file corresponding to the independent functional component into the executable file corresponding to the basic functional component.

4. The method according to claim 1, wherein in response to the function enabling instruction, matching the corresponding independent functional component of the application includes:

querying whether an extracted independent functional component has an executable file corresponding to a first function;

when the extracted independent functional component does not have the executable file corresponding to the first function, obtaining an unextracted independent functional component corresponding to the first function in the application; and

when the extracted independent functional component has the executable file corresponding to the first function, obtaining the extracted independent functional component.

5. The method according to claim 1, wherein in response to the function enabling instruction, matching the corresponding independent functional component of the application includes:

determining whether the executable file corresponding to the first function is valid;

when the extracted independent functional component does not have the executable file corresponding to the first function or the existed executable file corresponding to the first function is invalid, obtaining an unextracted independent functional component corresponding to the first function in the application; and

when the extracted independent functional component has the executable file corresponding to the first function, and the executable file corresponding to the first function is valid, obtaining the extracted independent functional component.

6. The method according to claim 5, wherein obtaining the executable file corresponding to the independent functional component includes one of:

extracting the unextracted independent functional component corresponding to the first function to obtain the executable file corresponding to the first function; and

obtaining the executable file corresponding to the first function from the extracted independent functional component.

7. The method according to claim 1, after loading the executable file corresponding to the independent functional component, further including:

acquiring component contents corresponding to the independent functional component; and

loading the component contents.

8. A user terminal, comprising:

a memory, configured to store program instructions for an application loading method, and

a processor, coupled to the memory and, when executing the program instructions, configured to:

in response to a function enabling instruction, match a corresponding independent functional component of an application, wherein the application is packaged in advance to include a plurality of different functional components based on differences in functions to be implemented, and the plurality of different functional components include the independent functional component;

obtain an executable file corresponding to the independent functional component; and

load the executable file corresponding to the independent functional component.

9. The user terminal according to claim 8, wherein:

the plurality of different functional components further include a basic functional component, wherein the processor is further configured to:

when detecting that the application is started, obtain an executable file corresponding to the basic functional component, and

load the executable file corresponding to the basic functional component into a memory of the user terminal.

10. The user terminal according to claim 9, wherein, when loading the executable file, the processor is further configured to:

incorporate the executable file corresponding to the independent functional component into the executable file corresponding to the basic functional component.

11. The user terminal according to claim 8, wherein the processor is further configured to:

query whether an extracted independent functional component has an executable file corresponding to a first function; and

acquire an unextracted independent functional component corresponding to the first function in the application, and to acquire the extracted independent functional component.

12. The user terminal according to claim 11, wherein the processor is further configured to:

determine whether the executable file corresponding to the first function is valid.

13. The user terminal according to claim 12, wherein the executable file is obtained by the processor configured to:

extract the unextracted independent functional component corresponding to the first function to obtain the executable file corresponding to the first function; and

obtain the executable file corresponding to the first function from the extracted independent functional component.

14. The user terminal according to claim 8, wherein the processor is further configured to:

acquire component contents corresponding to the independent functional component; and

load the component contents.

15. A non-transitory computer-readable storage medium containing computer-executable program instructions for, when executed by a processor, performing an application loading method, the method comprising:

16. The storage medium according to claim 15, wherein:

17. The storage medium according to claim 16, wherein loading the executable file corresponding to the independent functional component includes:

18. The storage medium according to claim 15, wherein in response to the function enabling instruction, matching the corresponding independent functional component of the application includes:

19. The storage medium according to claim 15, wherein in response to the function enabling instruction, matching the corresponding independent functional component of the application includes:

20. The storage medium according to claim 19, wherein obtaining the executable file corresponding to the independent functional component includes one of: