CN112698888A

CN112698888A - Application modularization, component calling and component initialization method and device

Info

Publication number: CN112698888A
Application number: CN202011582182.XA
Authority: CN
Inventors: 刘超群; 黎河军; 黄帆
Original assignee: Guangzhou Huya Technology Co Ltd
Current assignee: Guangzhou Huya Technology Co Ltd
Priority date: 2020-12-28
Filing date: 2020-12-28
Publication date: 2021-04-23
Anticipated expiration: 2040-12-28
Also published as: CN112698888B

Abstract

The application provides a componentization method and a componentization device of an application program, a component calling method and a component calling device of the application program, a component initialization method and a component initialization device of the application program, electronic equipment and a computer equipment storage medium; the modularization method comprises the following steps: configuring a static library file of a functional module; wherein the static library file comprises implementation code of the functional module of the application program; configuring at least one protocol file of the functional module; the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components; and performing component packaging on the static library file and the protocol file corresponding to the functional module. The application of the modular development framework provides the protocol file of the interface externally in an abstract mode, is used for calling the interface for other components, can remove the strong reference relation of calling between the components through the protocol file, realizes separation of the protocol file and the code, and greatly improves the running effect of the application program.

Description

Application modularization, component calling and component initialization method and device

Technical Field

The invention relates to the technical field of computers, in particular to a componentization method and device of an application program, a component calling method and device of the application program, a component initialization method and device of the application program, electronic equipment and a storage medium of the computer equipment.

Background

With continuous iteration and development of apps (foreign language full names: applications), service logic becomes more and more complex, and generally, one App comprises a plurality of functional modules, the different functional modules have a mutual calling relationship, the functional modules are seriously coupled with each other, and the maintenance cost is higher and higher; when a componentized scheme is used to organize the function code of an App, the inter-call relationships between different function modules must be handled well. Therefore, there is a need to develop a more rational componentization framework to achieve mutual decoupling and independent maintenance of different functional modules.

At present, the mainstream decoupling solution in the industry is realized based on a source code isolation and independent SDK splitting mode, and the decoupling solution needs to directly depend on a related header file and cannot realize complete decoupling; therefore, the scheme can better realize the direct structure and mutual calling of different components and achieve the purpose of completely removing the dependence among the components. For example, an App-a includes functions of logging in and watching live broadcast, and a user must log in before entering and watching live broadcast, so that the live broadcast module is considered to be dependent on the login module. After the componentization reconstruction, if the live broadcast module can be used by another App-B at the same time, the App-B has no login function, a user can directly see the live broadcast without logging in, and the live broadcast module and the login module are required to be completely decoupled at the moment.

However, in the above decoupling scheme, the code of the functional module includes all code implementations, and generally, the interface call is provided externally in a manner that a header file provides a class declaration, and this calling manner belongs to a strong reference relationship, and once the code implementation is not introduced into the engineering, a crash exception occurs in the code execution, which affects the operation effect of the application program.

Disclosure of Invention

The invention aims to solve at least one of the technical defects, particularly the technical defect that the execution of the code has crash exception and the running effect of the application program is influenced, and provides a solution.

In a first aspect:

the application provides a componentization method of an application program, which comprises the following steps:

configuring a static library file of a functional module; wherein the static library file comprises implementation code of the functional module of the application program;

configuring at least one protocol file of the functional module; the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components;

and performing component packaging on the static library file and the protocol file corresponding to the functional module.

In one embodiment, the step of configuring at least one protocol file of the functional module includes:

acquiring the capability information of the functional module;

describing the capability information as constraint rule information, and generating the protocol file by taking the constraint rule information as content;

in an embodiment, the step of performing component encapsulation on the static library file and the protocol file corresponding to the functional module includes:

packaging the components by taking the constraint rule information as an example, and packaging the components and at least one external interface for the second time to form a target component; the external interface is an interface for calling the protocol file.

In one embodiment, before configuring the static library file of the function module of the application program, the method further comprises:

dividing the application program into a plurality of functional modules according to the implementation function of the application program; wherein the functional module is implemented by at least one component.

In a second aspect:

the application provides a componentization device of an application program, comprising:

the first configuration module is used for configuring the static library file of the function module; wherein the static library file comprises implementation code of the functional module of the application program;

the second configuration module is used for configuring the protocol file of the functional module; the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components;

and the component packaging module is used for carrying out component packaging on the static library file and the protocol file corresponding to the functional module.

In a third aspect:

the application provides a component calling method of an application program, which comprises the following steps:

configuring a target external interface to be called in a protocol file of a calling component; the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components;

inquiring a target component for realizing the target external interface according to the configured target external interface; the target component is packaged with the target external interface and a static library file of the implementation code of the functional module of the application program;

and acquiring the instance of the target component according to the calling request of the calling component, and executing the implementation code of the target component.

In one embodiment, before the target component is called according to the call request of the calling component and the implementation code of the target component is executed, the method further includes:

querying the target component with a component manager whether an executable component instance object exists;

if yes, judging that the target component is initialized, and executing the method of the executed component instance object of the target component;

otherwise, judging that the target component does not finish initialization, waiting in a specified time period, and executing the executed component instance object of the target component after the target component finishes initialization.

In one embodiment, the step of configuring the target external interface to be called in the protocol file of the calling component includes:

declaring a target external interface to be called in a protocol file of a calling component; or copying the protocol file of the target component to the protocol file of the calling component.

In a fourth aspect:

the application provides a device for calling components of an application program, comprising:

the third configuration module is used for configuring a target external interface to be called in a protocol file of the calling component; the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components;

the component query module is used for querying a target component for realizing the target external interface according to the configured target external interface; the target component is packaged with the target external interface and a static library file of the implementation code of the functional module of the application program;

and the code execution module is used for acquiring the instance of the target component according to the calling request of the calling component and executing the implementation code of the target component.

In a fifth aspect:

the application provides a component initialization method of an application program, which comprises the following steps:

acquiring each component of the application program after receiving the starting signal; the component is obtained by packaging a static library file and a protocol file of the function module of an application program, wherein the static library file comprises an implementation code of the function module, and the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components;

configuring the dependency relationship among the components, and configuring the initialization sequence of each component according to the dependency relationship;

and responding to the starting signal and sequentially initializing each component according to the initialization sequence.

In one embodiment, the step of configuring the initialization sequence of each component according to the dependency relationship includes:

acquiring a first type of component which needs to be initialized in the main thread and a second type of component which does not need to be initialized in the main thread according to the dependency relationship;

configuring the first type of components as components initialized in series in a main thread, and configuring the second type of components as components initialized in parallel with the main thread;

the step of sequentially initializing each component according to the initialization sequence comprises:

performing initialization of the first class of components with the main thread and initialization of the second class of components with other parallel threads.

In one embodiment, the step of configuring the dependency relationship between the components comprises:

and determining the dependency relationship among the components according to the starting sequence of each component, the calling relationship among the components and/or the delay starting time.

In a sixth aspect:

the application provides a device for initializing components of an application program, comprising:

the component acquisition module is used for acquiring each component of the application program after receiving the starting signal; the component is obtained by packaging a static library file and a protocol file of the function module of an application program, wherein the static library file comprises an implementation code of the function module, and the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components;

the dependency configuration module is used for configuring the dependency relationship among the components and configuring the initialization sequence of the components according to the dependency relationship;

and the initialization execution module is used for responding to the starting signal and sequentially initializing each component according to the initialization sequence.

In a seventh aspect:

the application provides an electronic device, it includes:

one or more processors;

a memory;

one or more applications, wherein the one or more applications are stored in the memory and configured to be executed by the one or more processors, the one or more programs configured to: the method as described above is performed.

In an eighth aspect:

the present application provides a computer device storage medium having stored thereon a computer program which, when executed by a processor, implements the method as described above.

The technical scheme of the application has the following technical effects:

(1) through a componentized development framework, a protocol file of an interface is externally provided in an abstract mode and is used for carrying out interface calling on other components, compared with a strong reference relation for externally providing interface calling in a mode of providing class declaration, the protocol file can remove the strong reference relation for calling among the components, and the protocol file and a code are separated, so that the complete decoupling of the dependency relation among the components is realized, even if the specific code realization of the components is not introduced into a project, the code execution can not be broken down, and the code realization can be replaced, thereby greatly improving the operation effect of an application program.

(2) Based on the componentization framework, when the components are called, the target components of the target external interface are inquired and realized by configuring the target external interface to be called in a protocol file of the calling components, the calling requests of the calling components are executed by the target components, the components are independent, and the multiplexing of the components and the mutual calling among the components are realized; allowing the delay to wait until the component completes initialization before the component completes initialization solves the problem of exceptions and crashes caused by calling the component interface ahead of time.

(3) Based on the componentized framework, the dependency relationship among the components is completely decoupled, the dependency relationship among the components can be freely configured in the component initialization process, and the initialization sequence of the components is configured according to the dependency relationship; because the application program is very easy to configure the dependency relationship and the initialization sequence of different components, the code is easier to maintain and expand, the adjustment of the starting sequence can be completed only by modifying the configuration parameters, and the service components can be newly added only by adding one row of configuration codes.

Furthermore, according to the dependence sequence of the configuration, each component can be independently configured whether serial initialization needs to be carried out on the main thread or not, the component does not need to be configured to be initialized on the main thread, and the componentization framework can allocate different threads to the component to carry out parallel initialization so as to improve the starting speed of the application program; especially in practical application, the multi-core characteristic of the device can be fully utilized to accelerate the running speed of the application program and improve the use experience of the application program.

Additional aspects and advantages of the invention will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention.

Drawings

The foregoing and/or additional aspects and advantages of the present invention will become apparent and readily appreciated from the following description of the embodiments, taken in conjunction with the accompanying drawings of which:

FIG. 1 is a flow diagram of a componentization method for an application;

FIG. 2 is a schematic diagram of a componentized device architecture for an application;

FIG. 3 is a flow diagram of a component invocation method for an application;

FIG. 4 is a flow diagram of an exemplary method of performing a service objective;

FIG. 5 is a diagram illustrating the structure of a component calling device of an application;

FIG. 6 is a flow chart of a method for component initialization of an application;

FIG. 7 is a block diagram of an apparatus for initializing components of an application;

fig. 8 is a schematic structural diagram of an electronic device.

Detailed Description

Reference will now be made in detail to embodiments of the present invention, examples of which are illustrated in the accompanying drawings, wherein like or similar reference numerals refer to the same or similar elements or elements having the same or similar function throughout. The embodiments described below with reference to the drawings are illustrative only and should not be construed as limiting the invention.

As used herein, the singular forms "a", "an", "the" and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms "comprises" and/or "comprising," when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. It will be understood that when an element is referred to as being "connected" or "coupled" to another element, it can be directly connected or coupled to the other element or intervening elements may also be present. Further, "connected" or "coupled" as used herein may include wirelessly connected or wirelessly coupled. As used herein, the term "and/or" includes all or any element and all combinations of one or more of the associated listed items.

It will be understood by those skilled in the art that, unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs. It will be further understood that terms, such as those defined in commonly used dictionaries, should be interpreted as having a meaning that is consistent with their meaning in the context of the prior art and will not be interpreted in an idealized or overly formal sense unless expressly so defined herein.

According to the technical scheme, a mobile terminal modularization development framework can be constructed, the external calling interface of the modules is abstracted into the protocol file, and the modules are called through the protocol file, so that a modularization development and decoupling calling scheme of the application program is provided.

Referring to fig. 1, fig. 1 is a flow chart of a componentization method of an application, comprising the steps of:

s101, configuring a static library file of a functional module; wherein the static library file includes implementation codes of the functional modules of the application program.

In the scheme of the embodiment, the implementation code of the functional module of the application program App is used for generating a static library file, and the instance of the functional module is executed.

Generally, an application App comprises a plurality of functional modules, and different functional modules use a componentized scheme to organize the functional codes of the application App through a mutual calling relationship. Accordingly, in this embodiment, before configuring a static library file, the application program may be divided into a plurality of functional modules according to the implementation function of the application program; wherein the functional module is implemented by at least one component.

S102, configuring at least one protocol file of the functional module; the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components.

The method adopts the protocol file externally provided in an abstract mode, and the implementation codes of the protocol file and the static library file are not in one-to-one binding relationship but describe the relevant interface information in an abstract mode; compared with the conventional external header file, the external header file comprises the class declarations and the methods which are in one-to-one correspondence with the implementation codes, when other components are called, the type declarations of the external header file are required to be introduced into the project, and the interface can be called when the service is used; the corresponding relation is released through a protocol file mode, other components use/copy the contents of the protocol file, and the examples of the corresponding components can be called according to the contents of the protocol file.

The "Protocol file (Protocol)" in the present embodiment refers to a set of a series of method declarations. The Component (Component) refers to a service module composed of a plurality of source codes, realizes an independent logic function, and provides one or more protocol files for external function call.

In this embodiment, for the formation of the protocol file, the capability information of the function module may be obtained; and describing the capability information as constraint rule information, and generating the constraint rule information as content.

S103, packaging the static library file and the protocol file corresponding to the functional module.

The step is to carry out the component packaging process on the static library file and the protocol file corresponding to each functional module so as to realize the design of the componentized framework.

Specifically, the function description of the function module can be realized through a static library file, all the capabilities of the function module are described as constraint rule contents through the contents of a protocol file, the constraint rule contents are generated into a protocol file and are provided for other components to be used as calling interfaces, and when other components call the components, the interface of another component can be declared in the protocol file of the component; the protocol file of another component can be copied to the project of the component, the protocol file does not participate in compiling and mainly solves the problem of symbol matching, therefore, the calling mode among the components is a weak reference relation, and the interface of the component can be called as long as the protocol file of the component meets other constraint rule ranges; and even if the implementation code of the static library file is not introduced into the project, the execution of the caller code cannot crash because the protocol file and the implementation code have no binding relationship.

As an embodiment, in the component packaging process, the constraint rule information may be used as an example to package a component, and the component and at least one external interface are packaged for the second time to form a target component; the external interface is an interface for calling the protocol file.

Specifically, the constraint rule information is used as an example for component packaging, an external interface is provided for other components to call, when other components call a target component, the external interface is used for acquiring the example of the constraint rule information in the protocol file, the example is a capability related rule describing the function module and is not in one-to-one binding relationship with the implementation code of the static library file, therefore, in the execution process of the example, even if the implementation code of the static library file does not exist or change, the execution of the example is not influenced, the relationship decoupling is completely realized, and the code execution does not crash.

As described above, in the solution of this embodiment, through a componentized development framework, a protocol file of an interface is provided externally in an abstract manner, and is used to perform interface call on other components, and compared with a strong reference relationship of interface call provided externally in a manner of providing a class declaration, the protocol file can release the strong reference relationship of call between components, and the protocol file and a code are separated, so that complete decoupling of dependency relationship between components is achieved, even if a specific code implementation of a component is not introduced into a project, code execution will not crash, and the code implementation can also be replaced, thereby greatly improving an operation effect of an application program.

For example, the following steps are carried out: if an App-a includes login and live viewing functions, a user must log in before entering live viewing, and the live viewing module depends on the login module. After the componentization reconstruction, the live broadcast module can be used by another App at the same time, namely App-B, the App-B has no login function in practice, a user can directly see live broadcast without logging in, the technical scheme provided by the application can realize complete decoupling of the live broadcast module and the login module, and the App-B can also see live broadcast without strongly referring to App-A.

In order to make the technical solutions provided in the present application clearer, the componentization method of the application program is further described below with reference to an application example.

In a conventional solution, the code of a function module of the application App includes all code implementations, and typically provides an interface call to the outside in a way that a header file provides a class declaration, for example, the login module is composed of:

libhyudb.a: a static library file containing compiled implementation codes;

huyaloginproxy.h: the header file contains class declarations and methods;

the content of the outer header file huyaloginproxy.h is as follows:

the type declaration HuyaLoginProxy is introduced into other components during calling to call the interface, and the calling mode is as follows:

[ [ HuyaLoginProxy instance ] loginPasport: _. usernamemeTextField. textencPasswortd: encPascalpastCtx: [ selfloginContextStringForType:0] ]; the login interface is called through a single case of the class to realize account login;

the calling of the strong reference relation in the calling mode has the advantage that when the libhyudb.a is not introduced into the project, the code execution generates a crash exception.

By adopting the componentized framework of the technical scheme of the application, the protocol file and the implementation code of the component are completely separated, and the componentized framework comprises the following components:

a LibhyudbWrapper.a static library file, including all implementation codes;

a Headers/Ihyudbservice.h Protocol file (Protocol), an interface file provided externally in an abstract manner;

then, by component encapsulation, the corresponding content of the ihudebservice.h file is:

correspondingly, the calling mode of the component is changed into:

[ HT _ EXECUTOR (IhyudbService) loginPasport: _ usernameTextField.textencPassWord: encPasdwo rd appCtx: [ self logingContextStringForType: 0] ]; the acquisition of the IhyudbService instance is realized by the/HT _ EXECUTOR, and the predefined login interface can be called after the instance is acquired.

Based on the componentized framework, the calling mode is calling of weak reference relationship, namely, even if libhyudbWrapper.a is not introduced into engineering, because the executed instance is the login type HuyaLoginProxy and is not in one-to-one binding relationship with the implementation code, the code execution of the calling component does not crash, and the implementation of libhyudbWrapper.a can be replaced at will according to requirements.

An embodiment of a componentized apparatus for an application is set forth below.

Referring to fig. 2, fig. 2 is a schematic diagram of a componentized device structure of an application, including:

the first configuration module 101 is used for configuring a static library file of the function module; wherein the static library file comprises implementation code of the functional module of the application program;

a second configuration module 102, configured to configure a protocol file of the functional module; the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components;

and the component packaging module 103 is used for performing component packaging on the static library file and the protocol file corresponding to the functional module.

In this embodiment, the first configuration module 101 may divide the application program into a plurality of functional modules according to the implementation function of the application program before configuring the static library file; wherein the functional module is implemented by at least one component.

In this embodiment, the second configuration module 102 abstractly provides the external protocol file, and the implementation codes of the protocol file and the static library file are not in a one-to-one binding relationship, but describe the relevant interface information abstractly; compared with the conventional external header file, the external header file comprises the class declarations and the methods which are in one-to-one correspondence with the implementation codes, when other components are called, the type declarations of the external header file are required to be introduced into the project, and the interface can be called when the business is used. For the formation of the protocol file, the capability information of the functional module can be obtained; and describing the capability information as constraint rule information, and generating the constraint rule information as content.

In this embodiment, the component encapsulation module 103 may describe, by using a static library file, the function of a function module, describe all its capabilities as constraint rule contents by using the contents of a protocol file, generate a protocol file from the constraint rule contents, provide the protocol file to other components as a called interface, and declare an interface of another component in the protocol file of the component when the other component is to call the component; the protocol file of another component may also be copied to the item of the component.

For the component packaging process of the component packaging module 103, the constraint rule information may be used as an example to perform component packaging, and perform secondary packaging with at least one external interface to obtain a target component; the external interface is an interface for calling the protocol file.

According to the scheme, the protocol file of the interface is externally provided in an abstract mode through a componentized development framework and is used for carrying out interface calling on other components, compared with the mode of externally providing a class statement, the protocol file can remove the strong reference relation of calling between the components, and the protocol file and the code are separated, so that the complete decoupling of the dependency relation between the components is realized, even if the specific code implementation of the components is not introduced into a project, the code execution cannot crash, the code implementation can be replaced, and the operation effect of the application program is greatly improved.

The application componentization device and the application componentization method are in one-to-one correspondence, and related technical features and technical effects in the application componentization method embodiment are all applicable to the application componentization device embodiment, so that the statement is made.

The following describes an embodiment of the component calling method of the application program, and in describing related technical features of the component calling method of the application program, the definition and the analysis of the component may be defined and analyzed according to the component in the componentization method embodiment of the application program.

According to the application, mutual decoupling and independence among the assemblies are achieved through modularization, multiplexing of the assemblies is facilitated, a weak reference relation is established among the assemblies through the technical scheme, and when the assemblies are mutually inter-modulated among different assemblies, the application can achieve a new application program assembly calling method.

Referring to fig. 3, fig. 3 is a flowchart of a component calling method of an application, including the steps of:

s201, configuring a target external interface to be called in a protocol file of a calling component; the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components.

In this embodiment, for a method for configuring a target external interface to be called, a first scheme may declare the target external interface to be called in a protocol file of a calling component; and the second scheme can copy the protocol file of the target component into the protocol file of the calling component.

For the first solution, when another component needs to call the component, an interface of another component may be declared in a protocol file of the component, where the interface is an external interface of the protocol file; for the second scheme, the protocol file of another component is copied to the project of the component, the protocol file does not participate in compiling, the calling mode among the components is a weak reference relationship, and the external interface of the component can be called as long as the protocol file of the component meets other constraint rule ranges.

S202, inquiring a target component for realizing the target external interface according to the configured target external interface; and the target component is packaged with the target external interface and a static library file of the implementation code of the functional module of the application program.

In this step, the target component can be queried before calling by using the external interface provided by the target component of the application program, and if a certain target component is packaged with the target external interface, whether the target external interface has an executable instance, that is, whether a static library file of the implementation code of the function module of the application program exists is queried.

S203, obtaining the example of the target component according to the calling request of the calling component, and executing the implementation code of the target component.

In this step, the instance of the target component is acquired in response to the calling request of the calling component, and the implementation code of the target component is executed through the acquired instance, so that the calling process of the target component is realized.

In this embodiment, before executing the implementation code of the target component, the component manager may be further used to query whether an executable component instance object exists in the target component; if yes, judging that the target component is initialized, and executing the method of the executed component instance object of the target component; otherwise, judging that the target component does not finish initialization, waiting in a specified time period, and executing the executed component instance object of the target component after the target component finishes initialization.

According to the technical scheme, based on the componentization framework, when the components are called, the target components of the target external interfaces are inquired and realized by configuring the target external interfaces to be called in the protocol files of the calling components, the calling requests of the calling components are sent to the target components to be executed, the components are independent, and the multiplexing of the components and the mutual calling among the components are realized; allowing the delay to wait until the component completes initialization before the component completes initialization solves the problem of exceptions and crashes caused by calling the component interface ahead of time.

In order to make the technical solutions provided in the present application clearer, the following further describes a component calling method of an application program with reference to an application example.

Referring to FIG. 4, FIG. 4 is a flow diagram of an exemplary method of performing a service objective; in this application example, a macro T _ execute is defined, and the way of executing the service target method by the macro HT _ execute is:

s401, execute macro HT _ EXECUTOR;

specifically, HT _ execute encapsulates execution of the execute () method, and execution of the target method can be indirectly achieved through the execute interface;

s402, executing a method call Execute;

s403, find the type of response (class For Protocol) that is the same among other components;

specifically, the Execute () method finds the same response type in other components according to the declaration of the component;

s404, acquiring an execution Method Signature (instance Method For Selector);

specifically, a corresponding signature is obtained according to a target method to be executed, and whether the target method can be executed by the instance can be determined only by the method signature;

s405, obtaining an execution example (instance For Protocol) according to the Protocol file;

specifically, whether an instance object of an executable component exists can be inquired through an internal component manager; if yes, executing s406, otherwise executing s 407;

s406, executing the Target method (invoke With Target) by the evocative method, and ending;

s407, determining whether the instance object of the executable component does not complete the asynchronous initialization process (allowaync); if so, the process proceeds to s408,

s408, entering a wait state (sleep);

s409, judging whether the waiting time is met (the longest waiting time for delayed calling can be set to be 3 seconds); if so, ending the calling, otherwise, executing the asynchronous calling, and returning to s405 until the target method is executed after the initialization is completed.

Through the application example, because the protocol file is completely decoupled from the implementation code, in the initialization process of starting the application program App, if some components need to depend on other components, before the method call is carried out, whether the target component has already finished the initialization can be judged firstly, and by means of searching whether executable examples exist in the target component, if the executable examples do not exist in the target component, the execution of the components is not influenced to be terminated, but the delayed call can be allowed to be carried out, and the cyclic waiting is carried out until the components finish the initialization, so that the problems of abnormity and crash caused by calling the component interface in advance are avoided.

An embodiment of a component invocation means for an application is set forth below.

Referring to fig. 5, fig. 5 is a schematic diagram of a component calling apparatus of an application, including:

a third configuration module 201, configured to configure a target external interface to be called in a protocol file of a calling component; the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components;

the component query module 202 is configured to query a target component implementing the target external interface according to the configured target external interface; the target component is packaged with the target external interface and a static library file of the implementation code of the functional module of the application program;

the code execution module 203 is configured to obtain an instance of the target component according to the call request of the call component, and execute the implementation code of the target component.

In this embodiment, the third configuration module 201 may use an abstract mode to externally provide a protocol file, where implementation codes of the protocol file and a static library file are not in a one-to-one binding relationship, but use an abstract mode to describe related interface information; the corresponding relation is released through a protocol file mode, and other components use/copy the contents of the protocol file, namely, the instances of the corresponding components can be called according to the contents of the protocol file.

In this embodiment, the component query module 202 may query the target component before calling by using an external interface provided by the target component of the application program, and if a certain target component is packaged with the target external interface, then query whether the target external interface has an executable instance, that is, whether a static library file of the implementation code of the function module of the application program exists.

In this embodiment, the code execution module 203 may further query the target component for whether there is an executable component instance object by using the component manager before executing the implementation code of the target component; if yes, judging that the target component is initialized, and executing the method of the executed component instance object of the target component; otherwise, judging that the target component does not finish initialization, waiting in a specified time period, and executing the executed component instance object of the target component after the target component finishes initialization.

The code execution module 203 is specifically configured to respond to a call request of the calling component to acquire an instance of the target component, and execute the implementation code of the target component through the acquired instance, thereby implementing a call process on the target component.

The component calling device of the application program and the component calling method of the application program are in one-to-one correspondence, and relevant technical features and technical effects in the embodiment of the component calling method of the application program are all applicable to the embodiment of the component calling device of the application program, so that the application program is declared.

The following describes an embodiment of a component initialization method of an application, and in describing related technical features of the component initialization method of the application, for definition and analysis of a component, the definition and analysis of the component in the embodiment of the component call method of the application may be based on a componentization method of the application and the component call method of the application.

Referring to fig. 6, fig. 6 is a flowchart of a method for initializing components of an application, including the steps of:

s301, acquiring each component of the application program after receiving the starting signal; the component is obtained by packaging a static library file and a protocol file of the function module of the application program, the static library file comprises an implementation code of the function module, and the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components.

Specifically, the function description of the function module can be performed through the static library file, all the capabilities of the function module are described as the constraint rule content through the protocol file content, the constraint rule content is generated into a protocol file, and the protocol file is provided for other components to serve as calling interfaces, so that the calling mode among the components is a weak reference relationship, and the interfaces of the components can be called as long as the protocol file of the components meets the range of other constraint rules.

For example, the constraint rule information may be used as an example to perform component packaging, and perform secondary packaging on the constraint rule information and at least one external interface to obtain a target component; the external interface is an interface for calling the protocol file.

S302, configuring the dependency relationship among the components, and configuring the initialization sequence of the components according to the dependency relationship.

Specifically, through a componentized development framework, the protocol file can remove the strong reference relation of calling among the components, and the protocol file and the code are separated, so that the complete decoupling of the dependency relation among the components is realized, and even if the specific code implementation of the components is not introduced into a project, the code execution can not crash, so that the dependency relation among the components can be configured as required in the initialization process, and the initialization sequence of the components is determined.

As an embodiment, for configuring the dependency relationship between the components, the dependency relationship between the components may be determined according to the starting sequence of each of the components, the calling relationship between the components, and/or the delay starting time.

In the process, the dependency relationship, i.e. the calling relationship, can be set according to the starting sequence requirement of the application App, or the calling relationship requirement among the components, or the requirement of delayed starting of some components.

Further, for the method of configuring the initialization sequence of each component according to the dependency relationship, a first type of component that needs to be initialized in the main thread and a second type of component that does not need to be initialized in the main thread may be obtained according to the dependency relationship; the first type of components are configured as components initialized in series in a main thread, and the second type of components are configured as components initialized in parallel with the main thread.

In the embodiment, in order to improve the starting speed of the application program App, the framework can individually configure whether the initialization is required in the main thread for each component, or allocate different threads to the components to perform parallel initialization.

And S303, responding to the starting signal and sequentially initializing each component according to the initialization sequence.

Specifically, when the initialization start signal arrives, the components are initialized according to the initialization sequence, and as an embodiment, the initialization of the first class of components may be performed by using the main thread, and the initialization of the second class of components may be performed by using other parallel threads.

For example, serial initialization may be performed in a dependent order according to a component initialized in a main thread, and a component that does not need to be initialized in the main thread is configured, and then a different thread is assigned to the component to perform parallel initialization.

In the scheme of the embodiment, based on the componentized framework, the dependency relationship among the components is completely decoupled, in the component initialization process, the dependency relationship among the components can be freely configured, and the initialization sequence of the components is configured according to the dependency relationship; because the application program is very easy to configure the dependency relationship and the initialization sequence of different components, the code is easier to maintain and expand, the adjustment of the starting sequence can be completed only by modifying the configuration parameters, and the service components can be newly added only by adding one row of configuration codes. Moreover, according to the dependency sequence of the configuration, each component can be configured independently whether serial initialization needs to be performed on the main thread or not, or the component does not need to be configured to be initialized on the main thread, and the componentization framework can allocate different threads to the component to perform parallel initialization, so that the starting speed of the application program is improved.

By adopting the scheme of the embodiment, the multi-core characteristic of the equipment can be fully utilized to accelerate the running speed of the application program, and the use experience of the application program is improved.

In order to make the technical solutions provided in the present application clearer, the following further describes a component initialization method of an application program with reference to several application examples.

In the present application example, the description is made by the startup flow management of one application App. After the application program App completes componentization by accessing the framework provided by the application, the starting process of the application program App is the starting process of each business component, the components corresponding to different businesses have interdependency relation with each other, and based on the application for component decoupling, the initialization sequence of different components can be set and the starting performance of the application program App can be improved as much as possible.

Because the componentization framework supports the configuration of different component initialization dependency relationships, the initialization sequence between different components can be set according to requirements, and a typical application program App starting process configuration part code is introduced as follows:

the part of the schematic codes complete the initialization configuration of a service component, a network component (IMTPNetService), a log component (IMTPLogService), a push component (IhypushdkService), a login component (IhypudbService), a feedback component (IMTPFeedBackService) and the like.

Specifically, the componentization framework of the present application can provide for configuring dependencies between components according to external interfaces; in the above example, the configuration network component and the log component start up, i.e. perform initialization, the configuration push component and the login component perform initialization after the network component completes initialization production, and the configuration feedback component performs initialization after 1 second of start-up.

Compared with the conventional componentization framework, the dependency relationship among the components is fixed, the initialization must be executed according to the inherent order, and once the initialization process cannot be completed successfully by the dependent components, the caller cannot continue to execute the initialization, and the initialization must be executed serially depending on the inherent order.

Based on the technical scheme of the application, after the componentized framework provided by the application is accessed, the dependency relationship and the initialization sequence of different components can be configured very easily, and meanwhile, the codes of the components are easier to maintain and expand.

As shown in the above example, the technical solution of the present application supports configuring multiple components for parallel/serial initialization, each component can separately configure whether initialization is required in a main thread, and the components initialized in the main thread can perform serial initialization according to a dependent order; if the configuration component does not need to be initialized in the main thread, the componentization framework can allocate different threads to the component to execute parallel initialization so as to improve the starting speed of the application program App.

The configuration interface process for the main thread and the non-main thread may be as follows:

by parallel initialization processing, the multi-core characteristic of equipment (such as a multi-CPU smart phone) can be fully utilized to accelerate the running speed of the application program App of the mobile terminal, and the use experience of the application program App can be greatly improved.

An embodiment of a component initialization apparatus for an application is set forth below.

Referring to fig. 7, fig. 7 is a schematic structural diagram of a component initialization apparatus for an application, including:

the component acquiring module 301 is configured to acquire each component of the application program after receiving the start signal; the component is obtained by packaging a static library file and a protocol file of the function module of an application program, wherein the static library file comprises an implementation code of the function module, and the protocol file is an interface file externally provided in an abstract mode and used for carrying out interface calling on other components;

a dependency configuration module 302, configured to configure dependency relationships among the components, and configure initialization sequences of the components according to the dependency relationships;

and the initialization execution module 303 is configured to respond to the start signal and sequentially initialize each component according to the initialization sequence.

In this embodiment, the component obtaining module 301 may describe the function of the function module through the static library file, describe all the capabilities of the function module as constraint rule contents through the protocol file contents, generate a protocol file from the constraint rule contents, and provide the protocol file to other components as a called interface, so that the calling mode between the components is a weak reference relationship, and as long as the protocol file of the component conforms to other constraint rule ranges, the interface of the component may be called.

In this embodiment, the dependency configuration module 302 may release the strong reference relationship of the call between the components through a componentized development framework, and the protocol file and the code are separated, so as to implement complete decoupling of the dependency relationship between the components, and even if the specific code implementation of the components is not introduced into the engineering, the code execution will not crash.

Further, when configuring the initialization sequence of each component according to the dependency relationship, the dependency configuration module 302 may obtain a first class of components that need to be initialized in the main thread and a second class of components that do not need to be initialized in the main thread according to the dependency relationship; the first type of components are configured as components initialized in series in a main thread, and the second type of components are configured as components initialized in parallel with the main thread.

In this embodiment, the initialization execution module 303 may initialize each component according to an initialization sequence when an initialization start signal arrives, and as an embodiment, the initialization of the first class of components may be executed by using the main thread, and the initialization of the second class of components may be executed by using other parallel threads.

The component initialization device of the application program and the component initialization method of the application program are in one-to-one correspondence, and related technical features and technical effects in the embodiment of the component initialization method of the application program are all applicable to the embodiment of the component initialization device of the application program, so that the application program is declared.

Embodiments of the electronic device are set forth below.

The application provides an electronic equipment, it includes: one or more processors; a memory; one or more applications, wherein the one or more applications are stored in the memory and configured to be executed by the one or more processors, the one or more programs configured to: the method of any of the embodiments described above is performed.

As shown in fig. 8, fig. 8 is a schematic structural diagram of an electronic device, which includes: a processor 801 and a memory 803. Wherein the processor 801 is coupled to a memory 803, such as via a bus 802. Optionally, the computer device 800 may also include a transceiver 804. It should be noted that the transceiver 804 is not limited to one in practical applications, and the structure of the electronic device 800 is not limited to the embodiment of the present application.

The Processor 801 may be a CPU (Central Processing Unit), a general-purpose Processor, a DSP (Digital Signal Processor), an ASIC (Application Specific Integrated Circuit), an FPGA (Field Programmable Gate Array) or other Programmable logic device, a transistor logic device, a hardware component, or any combination thereof. Which may implement or perform the various illustrative logical blocks, modules, and circuits described in connection with the disclosure. The processor 801 may also be a combination of computing functions, e.g., comprising one or more microprocessors, a combination of a DSP and a microprocessor, or the like. Bus 802 may include a path that transfers information between the above components. The bus 802 may be a PCI (Peripheral Component Interconnect) bus, an EISA (Extended Industry Standard Architecture) bus, or the like. The bus 802 may be divided into an address bus, a data bus, a control bus, and the like. For ease of illustration, only one thick line is shown in FIG. 8, but this is not intended to represent only one bus or type of bus.

The Memory 803 may be a ROM (Read Only Memory) or other type of static storage device that can store static information and instructions, a RAM (Random Access Memory) or other type of dynamic storage device that can store information and instructions, an EEPROM (Electrically Erasable Programmable Read Only Memory), a CD-ROM (Compact Disc Read Only Memory) or other optical Disc storage, optical Disc storage (including Compact Disc, laser Disc, optical Disc, digital versatile Disc, blu-ray Disc, etc.), a magnetic disk storage medium or other magnetic storage device, or any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a computer, but is not limited to these.

The memory 803 is used for storing codes for executing the respective components of the application program of the present application scheme, and the execution is controlled by the processor 801. The processor 801 is configured to execute application program code stored in the memory 803 to implement the content shown in the foregoing method embodiments.

Wherein the electronic device includes but is not limited to: mobile terminals such as mobile phones, notebook computers, digital broadcast receivers, PDAs (personal digital assistants), PADs (tablet computers), PMPs (portable multimedia players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and the like, and fixed terminals such as digital TVs, desktop computers, and the like. The electronic device shown in fig. 8 is only an example, and should not bring any limitation to the functions and the scope of use of the embodiments of the present disclosure.

Embodiments of computer-readable storage media are set forth below.

The present application provides a computer-readable storage medium, on which a computer program is stored, which, when run on a computer, enables the computer to perform the corresponding content in the aforementioned method embodiments.

It should be understood that, although the steps in the flowcharts of the figures are shown in order as indicated by the arrows, the steps are not necessarily performed in order as indicated by the arrows. The steps are not performed in the exact order shown and may be performed in other orders unless explicitly stated herein. Moreover, at least a portion of the steps in the flow chart of the figure may include multiple sub-steps or multiple stages, which are not necessarily performed at the same time, but may be performed at different times, which are not necessarily performed in sequence, but may be performed alternately or alternately with other steps or at least a portion of the sub-steps or stages of other steps.

The foregoing is only a partial embodiment of the present invention, and it should be noted that, for those skilled in the art, various modifications and decorations can be made without departing from the principle of the present invention, and these modifications and decorations should also be regarded as the protection scope of the present invention.

Claims

1. A componentization method for an application, comprising the steps of:

2. The componentization method of claim 1, wherein the step of configuring at least one protocol file of the functional module comprises:

acquiring the capability information of the functional module;

and describing the capability information as constraint rule information, and generating the protocol file by taking the constraint rule information as content.

3. The componentization method of the application program according to claim 1, wherein the step of component packaging the static library file and the protocol file corresponding to the functional module comprises:

4. The componentization method of an application program according to claim 1, further comprising, before configuring a static library file of a function module of the application program:

5. An apparatus for componentizing an application, comprising:

6. A component calling method of an application program is characterized by comprising the following steps:

7. The method for calling the component of the application program according to claim 6, wherein before the calling the target component according to the calling request of the calling component, and executing the implementation code of the target component, the method further comprises:

8. The method for calling the component of the application program according to claim 6, wherein the step of configuring the target external interface to be called in the protocol file of the calling component comprises:

9. An apparatus for calling a component of an application, comprising:

10. A method for initializing a component of an application, comprising the steps of:

11. The method for initializing components of an application according to claim 10, wherein the step of configuring the initialization order of the components according to the dependency relationship comprises:

12. The method for initializing a component of an application according to claim 10, wherein said step of configuring a dependency relationship between each of said components comprises:

13. An apparatus for initializing a component of an application, comprising:

14. An electronic device, comprising:

one or more processors;

a memory;

one or more applications, wherein the one or more applications are stored in the memory and configured to be executed by the one or more processors, the one or more programs configured to: performing the method of any one of claims 1-4, 6-8 or 10-12.

15. A computer device storage medium on which a computer program is stored, which program, when being executed by a processor, is adapted to carry out the method of any one of claims 1-4, 6-8 or 10-12.