CN113986388A

CN113986388A - Program set loading method and system, electronic equipment and storage medium

Info

Publication number: CN113986388A
Application number: CN202111265738.7A
Authority: CN
Inventors: 王达
Original assignee: Shanghai Miha Youliyue Technology Co ltd
Current assignee: Shanghai Miha Youliyue Technology Co ltd
Priority date: 2021-10-28
Filing date: 2021-10-28
Publication date: 2022-01-28
Anticipated expiration: 2041-10-28
Also published as: CN113986388B

Abstract

The embodiment of the invention discloses a program set loading method, a program set loading system, electronic equipment and a storage medium, wherein the method comprises the following steps: the method comprises the steps that a client loads a native code library of a target project in the starting process of the target project; when the client finishes loading the native code library of the target project, loading a pre-constructed program loading hook file; the client loads a target plug-in sub-program set corresponding to the target project in an engine plug-in library based on the program loading hook file; the client starts the target item based on the target plug-in sub-program set. According to the technical scheme of the embodiment of the invention, the hook file is loaded through the loaded pre-constructed program in the starting process of the target project, the target plug-in sub-program set corresponding to the target project is loaded, and the engine plug-in library is not directly loaded in a full amount, so that the waste of memory resources can be effectively avoided, the project starting process is optimized, and the project starting efficiency is improved.

Description

Program set loading method and system, electronic equipment and storage medium

Technical Field

The embodiment of the invention relates to the technical field of computer application, in particular to a program set loading method, a program set loading system, electronic equipment and a storage medium.

Background

In the course of the project operation, the realization of each function often depends on a sub-program set corresponding to the function in the program set related to the project. In a project, various functions are often provided, which requires loading of a set of sub-programs corresponding to the various functions.

Currently, the related art processes a project by loading all sub program sets in a program set related to the project and then running the project. However, such full loading has a drawback that there are often many sub-program sets in the program set related to the project, and functions that may be applied by different users are different, so that all the loaded sub-program sets may not be used, which may cause memory resource waste of the user terminal and affect user experience.

Disclosure of Invention

The embodiment of the invention provides a program set loading method, a program set loading system, electronic equipment and a storage medium, which are used for realizing dynamic loading and personalized loading of a project subprogram set.

In a first aspect, an embodiment of the present invention provides a method for loading a program set, including:

the method comprises the steps that a client loads a native code library of a target project in the starting process of the target project;

when the client finishes loading the native code library of the target project, loading a pre-constructed program loading hook file;

the client loads a target plug-in sub-program set corresponding to the target project in an engine plug-in library based on the program loading hook file;

the client starts the target item based on the target plug-in sub-program set.

In a second aspect, an embodiment of the present invention further provides a program set loading system, which is characterized by including a client, where the client includes:

the native code library loading module is used for loading the native code library of the target project in the starting process of the target project;

the hook file loading module is used for loading a pre-constructed program loading hook file when the loading of the native code library of the target project is finished;

the subprogram set loading module is used for loading a target plugin subprogram set corresponding to the target project in the engine plugin library based on the program loading hook file;

the target item starting module: for launching the target item based on the set of target plug-in sub-programs.

In a third aspect, an embodiment of the present invention further provides an electronic device, where the electronic device includes:

one or more processors;

a storage device for storing one or more programs,

when the one or more programs are executed by the one or more processors, the one or more processors are caused to implement the program set loading method provided by any embodiment of the present invention.

In a fourth aspect, an embodiment of the present invention further provides a computer-readable storage medium, on which a computer program is stored, where the computer program, when executed by a processor, implements the program set loading method provided in any embodiment of the present invention.

According to the technical scheme, the pre-constructed program loading hook file is loaded in the starting process of the target project, the sub-program set in the engine plug-in library is loaded based on the program loading hook file, and the target plug-in sub-program set corresponding to the target project is loaded instead of directly loading the engine plug-in library in a full amount. Furthermore, the operation of starting the target project is continuously executed based on the target plug-in sub-program set, so that the problem of memory resource waste caused by full-load of the sub-program set in the prior art is solved, and the technical effects of saving memory resources, optimizing project starting processes and improving project starting efficiency are achieved.

Drawings

In order to more clearly illustrate the technical solutions of the exemplary embodiments of the present invention, a brief description is given below of the drawings used in describing the embodiments. It should be clear that the described figures are only views of some of the embodiments of the invention to be described, not all, and that for a person skilled in the art, other figures can be derived from these figures without inventive effort.

Fig. 1 is a flowchart illustrating a program set loading method according to an embodiment of the present invention;

fig. 2 is a flowchart illustrating a program set loading method according to a second embodiment of the present invention;

fig. 3 is a schematic flowchart of a program set loading method in an application scenario according to a third embodiment of the present invention;

fig. 4 is a schematic structural diagram of a client of the assembly loading system according to the fourth embodiment of the present invention;

fig. 5 is a schematic structural diagram of an electronic device according to a fifth embodiment of the present invention.

Detailed Description

The present invention will be described in further detail with reference to the accompanying drawings and examples. It is to be understood that the specific embodiments described herein are merely illustrative of the invention and are not limiting of the invention. It should be further noted that, for the convenience of description, only some of the structures related to the present invention are shown in the drawings, not all of the structures.

It should be further noted that, for the convenience of description, only some but not all of the relevant aspects of the present invention are shown in the drawings. Before discussing exemplary embodiments in more detail, it should be noted that some exemplary embodiments are described as processes or methods depicted as flowcharts. Although a flowchart may describe the operations (or steps) as a sequential process, many of the operations can be performed in parallel, concurrently or simultaneously. In addition, the order of the operations may be re-arranged. The process may be terminated when its operations are completed, but may have additional steps not included in the figure. The processes may correspond to methods, functions, procedures, subroutines, and the like.

In the embodiments of the present invention, a project may be understood as a variety of software engineering developed by a developer. The target item can be understood as the item corresponding to the current starting process. For convenience of understanding, before the specific technical solution of the embodiment of the present invention is introduced, a target item is taken as an example of a game-like item, and an item starting process is introduced. Specifically, the starting process of the target item may include the following steps: 1. initializing a project operation environment; 2. loading a full amount program set required by the target project; 3. a shader required to load the target item; 4. loading a numerical value file of a target project; 5. entering a login process of a target project; 4. and (5) running the game and entering a game interface. Wherein, the full-scale ordered set required by the target project comprises: the system comprises an engine native code library corresponding to a target project, an engine plug-in layer program set corresponding to the engine native code library, a project engineering program set of the target project and a third party library program set corresponding to the project engineering program set.

Wherein, the project engineering assembly can contain all program codes of project engineering; such as the complete program code of a game Project, may be dll file code of Project series. The third party library program set may be a third party software development kit or a third party plug-in library program set, etc.

Example one

Fig. 1 is a flowchart of a program set loading method according to an embodiment of the present invention, where the embodiment is applicable to a case where a program set is loaded in a process of starting a target item, and the method may be executed by a program set loading apparatus, where the apparatus may be implemented by software and/or hardware, and may be configured in a terminal and/or a server to implement the program set loading method according to the embodiment of the present invention.

As shown in fig. 1, the method of this embodiment specifically includes the following steps:

s110, loading the native code library of the target project by the client in the starting process of the target project.

Wherein a client may be understood as a program that provides a user with interactive services with a target item. Specifically, the client may be understood as an application program of a target item installed in the user terminal. Optionally, when the target item is a game item, the client may be a game client.

As previously mentioned, the target item may be the item that needs to be launched at the current time. Optionally, the target item may be an application installed in the intelligent terminal, where the intelligent terminal may be a mobile phone terminal, a PC terminal, or the like.

Wherein the native code library of the target project can be understood as a basic code file supporting the starting of the target project. The language in which the native code library is written may be the C # language. Alternatively, the native code library may be a unitin. dll library or the like.

Specifically, when the client receives a start instruction for starting the target project from the user, the file position of the native code library of the target project may be determined, and the native code library may be loaded into the memory according to the file position of the native code library of the target project.

And S120, when the loading of the native code library of the target project is finished, the client loads a pre-constructed program loading hook file.

The program loading hook file may be a file for selecting a desired program set to load. In particular, the program load hook file may contain instructions for the loading of a set of subroutines. The program load hook file may be a. dll file or a. lab file, etc.

For example, the program loading hook file may be an enginepre entryhook.dll file, and an engineering enginepre entryhook may be pre-constructed based on a C # generation dll method of the target project engine, so as to generate an enginepre entryhook.dll file, which is used as the program loading hook file.

In the embodiment of the invention, the program loading hook file can be constructed in advance based on the native code library. By loading the hook file by the code builder of the native code library, it is intended to reduce the time and effort taken by a developer in building the hook file loaded by the program.

Specifically, when it is detected that the native code library of the target item is loaded completely, a pre-constructed assembly load hook file for loading the assembly set may be loaded into the memory.

S130, the client loads a target plug-in sub-program set corresponding to the target project in the engine plug-in library based on the program loading hook file.

The engine plug-in library can be understood as a program written by an application program interface according to a certain specification. Alternatively, an engine plug-in library may be understood as a repository storing various plug-ins for supporting engine startup. The set of engine plug-in layer programs of the target item may contain engine plug-in layer code or program code that invokes native code. Such as dll files containing package and plugin families.

Wherein, the target plug-in sub-program set can be understood as the plug-in program needed when starting the target project. In the embodiment of the present invention, which sub-program sets in the engine plug-in library are specifically used as target plug-in sub-program sets are not specifically limited, and may be determined according to the starting requirements of the target project.

Because the users or applicable projects to which the engine plug-in library is directed are very wide, the engine plug-in library often includes a large number of plug-in sub-assemblies. However, different items require different plug-in sub-program sets at startup, and particularly, only a part of the plug-in sub-program sets are needed during startup. The related technology is always full load when the subprogram in the engine plug-in library is loaded. In the embodiment of the present invention, specifically, based on the program loading hook file, the target plug-in sub-program set corresponding to the target item may be determined, and then only the target plug-in sub-program set is loaded without performing full loading, so that dynamic loading of the sub-program set in the engine plug-in library is realized, and a purpose of saving a starting memory is achieved.

The method for determining the target plug-in sub-program set corresponding to the target item based on the program loading hook file may be various, for example, the method may include calling the program loading hook file, and determining the target plug-in sub-program set corresponding to the target item according to a preset identification rule. Illustratively, the preset recognition rule may be a preset assembly acquisition path, or a preset assembly key character or the like. The specific identification rule may be set according to actual requirements, and is not specifically limited herein.

And S140, starting the target project by the client based on the target plug-in sub-program set.

Specifically, when the native code library of the target project and the sub-assembly set of the target plug-in are loaded completely, the client may start the target project based on the loaded assembly set.

As previously described, the project engineering suite of target projects and the third party libraries corresponding to the project engineering suite may continue to be loaded. The third-party library can be a third-party software development kit or a third-party plug-in library program set.

According to the technical scheme of the embodiment of the invention, the target plug-in sub-program set corresponding to the target project is loaded and started by loading the pre-constructed program loading hook file in the starting process of the target project and loading and deleting the sub-program set in the engine plug-in library based on the program loading hook file. Furthermore, the operation of starting the target project is continuously executed based on the target plug-in sub-program set, so that the problem of memory resource waste caused by full-load of the sub-program set in the prior art is solved, the project starting process is optimized, and the project starting efficiency is improved.

Example two

Fig. 2 is a schematic flow chart of a program set loading method according to a second embodiment of the present invention, and the second embodiment further details the technical solution based on the technical solution. On the basis of any optional technical solution in this embodiment of the present invention, optionally, after the loading the target plug-in sub-program set, the method further includes: the client loads a project starting subprogram set in a project engineering program set based on the program loading hook file; the client starts the target item based on the target plug-in sub program set, and the method comprises the following steps: the client launches the target item based on the set of target plug-ins and the set of item promoter programs.

On the basis of any optional technical solution of the present invention, optionally, after the client starts the target item based on the target plug-in sub-program set, the method further includes: and the client displays a login interface of the target project, receives login information input by a target user on the login interface, and operates the target project based on the login information.

The technical terms that are the same as or corresponding to the above embodiments are not repeated herein. As shown in fig. 2, the method of this embodiment specifically includes the following steps:

s210, the client loads the native code library of the target project in the starting process of the target project.

And S220, when the loading of the native code library of the target project is finished, the client loads a pre-constructed program loading hook file.

S230, loading a target plug-in sub-program set corresponding to the target project in the engine plug-in library by the client based on the program loading hook file.

S240, loading a project starting subprogram set in the project engineering program set by the client based on the program loading hook file.

The project engineering assembly can be understood as all source program code files of the project engineering which are to be loaded and developed based on the target project. Taking the target project as the game project as an example, the project engineering assembly can be understood as the whole program code of the game project. Specifically, the entire program code of the game Project may be dll file code of Project series. A project sub-set of sub-programs may be understood as a set of sub-programs needed in a project engineering set for launching the target project.

Wherein the project starting sub program set comprises a basic sub program set used for starting the target project, or comprises a common sub program set and a basic sub program set used for starting the target project. The common sub program set comprises a sub program set of which the calling frequency of the project engineering sub program set reaches a preset frequency threshold value and/or the number of terminals calling the project engineering sub program set reaches a preset number threshold value.

Wherein a basic set of sub-programs can be understood as various code files for the basic functions of the project when the target project is started.

The calling frequency of the project engineering subprogram set may be the calling frequency of the project engineering subprogram set called by the target terminal currently running the target project, or the calling frequency of the project engineering subprogram set called by two or more target terminals. Specifically, the calling frequency of which terminals are adopted to call the project engineering subprogram set can be set according to actual requirements, and is not specifically limited herein. For example, the sum or average of the frequencies of the calling frequencies of all the terminals belonging to the same area as the target terminal calling the project engineering sub-program set may be used. It is understood that the calling frequency of the project engineering sub-set refers to the number of times the project engineering sub-set is called per unit time. The preset frequency threshold may be preset according to actual requirements, and specific values thereof are not limited herein.

For example, the number of terminals calling the project engineering sub program set may be the number of terminals calling the project engineering sub program set from all terminals that have run the target project, or the number of terminals calling the project engineering sub program set from terminals that belong to the same area as the target terminal that currently runs the target project. Optionally, the number of terminals calling the project engineering sub-program set in a preset time period is counted. For example, within a period of time closest to the current time, for example, within the last 1 month from the current time. Similarly, the preset number threshold may also be preset according to actual requirements. For example, the number of terminals may be determined in a statistical manner, and a specific value thereof is not limited herein.

Specifically, for example, when the server detects that a game item is started, a sub-program set corresponding to a battle scene in the game item is frequently called, and then the program loading hook file preferentially loads the sub-program sets of the boss battle and the pvp.

Optionally, before the client loads, based on the program loading hook, a target plug-in sub-assembly set corresponding to the target item in the engine plug-in library, the method further includes: the client stores a project starting subprogram set in a first storage space of a target terminal for operating the target project; accordingly, the client loads a project promoter assembly in a project engineering assembly based on the program loading hook file, including: and the client loads a project starting subprogram set in the project engineering program set from the first storage space based on the program loading hook file.

It should be noted that the project engineering assembly includes, but is not limited to, a project promoter assembly, and in order to facilitate loading of the project promoter assembly, the client may store the project promoter assembly in the first storage space of the target terminal running the target project in advance. The advantage of this is that the client can start the project by loading the project promoter program set in the project engineering program set from the first storage space based on the program loading hook file, and compared with the previous way of storing all the sub program sets in the project engineering program set together, the loading accuracy and the loading efficiency of the project promoter program set are higher.

Specifically, after the fact that the target plug-in sub-program set is loaded is detected, the project engineering program set can be processed through the program loading hook file, and a project sub-program set used for starting a target project is selected to be loaded, so that the purpose of saving loading memory is achieved.

And S250, starting the target project by the client based on the target plug-in sub program set and the project starting sub program set.

As described above, in the starting process of the target project, many program sets are loaded, and compared with the full-load loading of the engine plug-in library and the project engineering program set, only the target plug-in sub-program set and the project starting sub-program set are loaded, so that under the condition that the project is guaranteed to be started smoothly, the loading memory is saved, and the user experience is improved.

And S260, the client displays a login interface of the target project, receives login information input by a target user on the login interface, and operates the target project based on the login information.

Specifically, when the target project is operated, the target project enters a login interface after a starting process. The login interface may include a login display screen and an interface component for inputting login information, such as a login box. The target user may enter login information on a login interface of the target item. After the client receives the login information input by the target user on the login interface, the target item can be operated according to the login information, and the item information corresponding to the login information is displayed. Typically, the login information may be an account number and a password of the target user.

Considering that different users have different individual behaviors in the running process of the target project, the requirements of the sub-program sets of the target project are different. Optionally, the running the target item based on the login information specifically includes: the client sends the login information and the current behavior data of the target user to an edge server based on the program loading hook file, so that the edge server determines the information to be loaded of the sub program set to be loaded corresponding to the target user based on the login information and the current behavior data; the client receives the information to be loaded of the sub program set to be loaded, which is fed back by the edge server, and loads the sub program set to be loaded based on the information to be loaded; and the client runs the target project based on the set of sub programs to be loaded.

The current behavior data can be understood as behavior data generated when the user runs the target item at the current moment. Illustratively, the current behavior data may be at least one of identity data, level data, project progress data, project manipulation data, and affiliated project branch data of the target user.

The edge server can be understood as a front-end server which can interact with the client, collect and store behavior data of a user running the target project, and can analyze the behavior data. Specifically, the client sends the login information and the current behavior data of the user to the edge server, the edge server performs a series of operation analysis to obtain data which may be subsequently interested by the target user, so that the program loading hook file determines and determines the information to be loaded of the sub program set to be loaded of the target user according to measurement and calculation of the edge server, and sends the information to the client, so that the client loads the sub program set to be loaded based on the received information to be loaded, and continues to run the target item according to the sub program set to be loaded.

Further, the determining, by the edge server, the information to be loaded of the set of sub programs to be loaded corresponding to the target user based on the login information and the current behavior data may specifically include: the edge server acquires first historical behavior data of the target user based on the login information; if the first historical behavior data is obtained, determining to-be-loaded information of a to-be-loaded sub-program set corresponding to the target user based on the current behavior data and the historical behavior data; and if the edge server does not acquire the first historical behavior data, determining a reference user based on the login information, acquiring second historical behavior data of the reference user, and determining information to be loaded of the sub program set to be loaded corresponding to the target user based on the current behavior data and the second historical behavior data.

The method has the advantages that the selective loading of the subprogram set can be realized in the running of the target item, and the memory resource occupied by the running of the game is saved.

The first historical behavior data can be understood as various behavior data about the target project of the target user before the target project is run at this time.

Wherein, the reference user can be understood as other users who run the same target project with the target user. The second historical behavior data can be understood as historical behavior information of other users operating the target item.

Specifically, when the edge server receives the login information of the target user, the previous behavior data of the target user is called, the subsequent behavior data of the target user when the target user operates the target project is obtained through operation and analysis, and the program loading hook file can load a corresponding sub-program set according to the operation of the edge server, so that better user experience is brought to the user.

Optionally, if the target user runs the target item for the first time, the edge server may call various behavior data of other users about the target item, and perform operation analysis on the behavior data to obtain common behavior data of other users about the target item, and the client may selectively load a corresponding set of subroutines to run the target item based on the program loading hook file according to a result of the operation of the edge server.

For example, determining the information to be loaded of the set of sub programs to be loaded corresponding to the target user based on the current behavior data and the second historical behavior data may include: and determining reference behavior data corresponding to the current behavior data in the second historical behavior data, and further determining information to be loaded of the sub program set to be loaded corresponding to the target user based on the reference behavior data. Further, the reference behavior data corresponding to the current behavior data in the second historical behavior data may be determined by taking the historical behavior data, of which the data similarity with the current behavior data exceeds a preset similarity threshold, in the second historical behavior data as the reference behavior data corresponding to the current behavior data. The data similarity may be determined by a ratio of the number of types of behavior data belonging to the same type to the number of types of behavior data belonging to different types, among the types of behavior data divided in advance. Or, comparing whether the information to be compared preset in the behavior data is consistent or not.

According to the technical scheme, the pre-constructed program loading hook file is loaded in the starting process of the target project, so that not only can the target plug-in sub-program set in the engine plug-in library be loaded based on the program loading hook file, but also the project sub-program set in the project engineering program set can be loaded based on the program loading hook file, the project engineering program set can also be selectively loaded, and the purpose of saving more loading memories in the starting process of the target project is achieved. Furthermore, in the running process of the target project, based on the operation of the edge server on the login information and the behavior data of the target project, the sub-program set is selectively loaded based on the program loading hook file, so that the loading memory in the running stage is saved, the project starting process is further optimized, and the technical effect of improving the project starting efficiency is achieved.

EXAMPLE III

In order to make the technical solutions of the embodiments of the present invention further clear to those skilled in the art, a specific application scenario example is given below by taking a target item as a game and taking a target terminal for starting the game as a client installed on a mobile phone as an example.

Fig. 3 is a schematic flowchart of a method for loading a program set in an application scenario according to an embodiment of the present invention; as shown in fig. 3, the target item is a mobile gaming application.

The method of the embodiment of the invention can comprise the following steps:

before a mobile phone client starts a game, a program is constructed in advance to load a hook file. Specifically, a dll method is generated by using c # of a native code library, an engineering EnginePreEntryHook for loading a hook file by a program is constructed in advance, and a file EnginePreEntryHook.dll in a dynamic link database format is generated. And implementing an assembly manager AssemblyMgr in EnginePreEntryhook for loading the sub-assembly.

Loading a native code library of an engine by a mobile phone client in the starting process of a game;

loading the EnginePreEntryHook when the loading of the native code library of the engine is finished; then, a common subroutine set is obtained by utilizing forward extension operation of the edge server, and based on the EnginePreEntryHook, a target plugin subroutine set corresponding to the target item in the engine plugin library is loaded, wherein the target plugin subroutine set is generally a commonly used engine plugin subroutine set in the engine plugin library, such as a timeline plugin subroutine set, and an item promoter subroutine set in the item engineering program set, such as a basic subroutine set and a common subroutine set used for starting the target item, and may be, for example, a routine set of a main flow in the item engineering program set (e.g., a routine set marked with key marks such as main or comom), a dll file of a common fighting routine set and/or a dll file of a world exploration routine set, and the like;

then, entering a login interface, inputting login information by a user, and running the game by the client.

At the moment, in the running process of the game, the edge server is used for collecting the current behavior data and the login information of the user, the subsequent behavior data of the player is obtained by calculating various data, the sub program set to be loaded is further determined, the information to be loaded of the sub program set to be loaded is transmitted to the client side, the client side loads the sub program set to be loaded according to the information to be loaded based on the EnginePreEntryhook file, the selective loading of the sub program set is achieved, and the internal memory is saved. For example, if the player is in good combat, the subsequent program set of the boss battle and the pvp is loaded preferentially; if the player is socially good, priority is given to the set of programs that load the home system.

According to the technical scheme, the pre-constructed program loading hook file is loaded in the target project starting process, the target plug-in sub-program set in the engine plug-in library is loaded based on the program loading hook file, and the project starting sub-program set in the project engineering program set is loaded, so that the purpose of saving the loading memory in the target project starting process is achieved. Furthermore, based on the operation stage of the target project, the program set is selectively loaded through the operation of the edge server, so that the memory occupied by the game operation is further saved, and the user experience is greatly improved.

Example four

Fig. 4 is a schematic structural diagram of a program set loading system according to a third embodiment of the present invention, where the program set loading system includes a client, where the client includes: a native code library loading module 410, a hook file loading module 420, a subroutine set loading module 430 and a target project starting module 440.

The native code library loading module 410 is configured to load a native code library of a target project in a starting process of the target project; the hook file loading module 420 is configured to load a pre-constructed program loading hook file when the loading of the native code library of the target project is completed; the plug-in sub-program set loading module 430 is used for loading a target plug-in sub-program set corresponding to the target item in the engine plug-in library based on the program loading hook file; an item starting module 440, configured to start the target item based on the target plug-in sub-program set.

Optionally, the client further includes:

the project promoter program set loading module is used for loading a project promoter program set in the project engineering program set based on the program loading hook file after the target plug-in sub program set is loaded;

the item starting module 440 is further configured to start the target item based on the set of target plug-ins and the set of item promoter programs.

Optionally, the project promoter assembly loading module is further configured to start a basic sub-assembly set of the target project, or a common sub-assembly set and start the basic sub-assembly set of the target project.

Optionally, the client further includes:

the project starting sub program set storage module is used for storing the project starting sub program set in a first storage space of a target terminal for operating the target project; correspondingly, the project promoter assembly loading module is further configured to load a project promoter assembly in a project engineering assembly from the first storage space based on the program loading hook file.

Optionally, the client further includes:

and the login information receiving module is used for displaying a login interface of the target project, receiving login information input by a target user on the login interface, and operating the target project based on the login information.

Optionally, the login information receiving module further includes an information sending unit and a sub-program set loading unit.

The information sending unit is used for sending the login information and the current behavior data of the target user to an edge server based on the program loading hook file so that the edge server determines the information to be loaded of the sub program set to be loaded corresponding to the target user based on the login information and the current behavior data; and the subprogram set loading unit is used for receiving the information to be loaded of the subprogram set to be loaded, which is fed back by the edge server, and loading the subprogram set to be loaded based on the information to be loaded.

Optionally, the system further includes an edge server, where the edge server includes an information determining module to be loaded; the information to be loaded determining module is used for acquiring first historical behavior data of the target user based on the login information; if the first historical behavior data is obtained, determining to-be-loaded information of a to-be-loaded sub-program set corresponding to the target user based on the current behavior data and the historical behavior data; and if the first historical behavior data is not acquired, determining a reference user based on the login information, acquiring second historical behavior data of the reference user, and determining information to be loaded of the sub program set to be loaded corresponding to the target user based on the current behavior data and the second historical behavior data.

The program set loading system can execute the program set loading method provided by any embodiment of the invention, and has the corresponding functional modules and beneficial effects of executing the program set loading method.

It should be noted that, the units and modules included in the program set loading system are merely divided according to functional logic, but are not limited to the above division as long as the corresponding functions can be implemented; in addition, specific names of the functional units are only for convenience of distinguishing from each other, and are not used for limiting the protection scope of the embodiment of the invention.

EXAMPLE five

Fig. 5 is a schematic structural diagram of an electronic device according to a fifth embodiment of the present invention. FIG. 5 illustrates a block diagram of an exemplary electronic device 50 suitable for use in implementing embodiments of the present invention. The electronic device 50 shown in fig. 5 is only an example, and should not bring any limitation to the functions and the scope of use of the embodiment of the present invention.

As shown in fig. 5, electronic device 50 is embodied in the form of a general purpose computing device. The components of the electronic device 50 may include, but are not limited to: one or more processors or processing units 501, a system memory 502, and a bus 503 that couples the various system components (including the system memory 502 and the processing unit 501).

Bus 503 represents one or more of any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, a processor, or a local bus using any of a variety of bus architectures. By way of example, such architectures include, but are not limited to, Industry Standard Architecture (ISA) bus, micro-channel architecture (MAC) bus, enhanced ISA bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI) bus.

Electronic device 50 typically includes a variety of computer system readable media. Such media may be any available media that is accessible by electronic device 50 and includes both volatile and nonvolatile media, removable and non-removable media.

The system memory 502 may include computer system readable media in the form of volatile memory, such as Random Access Memory (RAM)504 and/or cache memory 505. The electronic device 50 may further include other removable/non-removable, volatile/nonvolatile computer system storage media. By way of example only, storage system 506 may be used to read from and write to non-removable, nonvolatile magnetic media (not shown in FIG. 5, commonly referred to as a "hard drive"). Although not shown in FIG. 5, a magnetic disk drive for reading from and writing to a removable, nonvolatile magnetic disk (e.g., a "floppy disk") and an optical disk drive for reading from or writing to a removable, nonvolatile optical disk (e.g., a CD-ROM, DVD-ROM, or other optical media) may be provided. In these cases, each drive may be connected to the bus 503 by one or more data media interfaces. Memory 502 may include at least one program product having a set (e.g., at least one) of program modules that are configured to carry out the functions of embodiments of the invention.

A program/utility 508 having a set (at least one) of program modules 507 may be stored, for instance, in memory 502, such program modules 507 including, but not limited to, an operating system, one or more application programs, other program modules, and program data, each of which examples or some combination thereof may comprise an implementation of a network environment. Program modules 507 generally perform the functions and/or methodologies of embodiments of the invention as described herein.

The electronic device 50 may also communicate with one or more external devices 509 (e.g., keyboard, pointing device, display 510, etc.), with one or more devices that enable a user to interact with the electronic device 50, and/or with any devices (e.g., network card, modem, etc.) that enable the electronic device 50 to communicate with one or more other computing devices. Such communication may occur via input/output (I/O) interfaces 511. Also, the electronic device 50 may communicate with one or more networks (e.g., a Local Area Network (LAN), a Wide Area Network (WAN), and/or a public network, such as the Internet) via the network adapter 512. As shown, the network adapter 512 communicates with the other modules of the electronic device 50 over the bus 503. It should be appreciated that although not shown in FIG. 5, other hardware and/or software modules may be used in conjunction with electronic device 50, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage systems, among others.

The processing unit 501 executes various functional applications and data processing by executing programs stored in the system memory 502, for example, to implement the program set loading method provided by the embodiment of the present invention.

EXAMPLE six

An embodiment of the present invention further provides a storage medium containing computer-executable instructions, which when executed by a computer processor, perform a method for loading a program set, the method including:

the client starts the target item based on the target plug-in sub-program set.

Computer storage media for embodiments of the invention may employ any combination of one or more computer-readable media. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.

A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.

Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

Computer program code for carrying out operations for embodiments of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C + + or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider).

It is to be noted that the foregoing is only illustrative of the preferred embodiments of the present invention and the technical principles employed. It will be understood by those skilled in the art that the present invention is not limited to the particular embodiments described herein, but is capable of various obvious changes, rearrangements and substitutions as will now become apparent to those skilled in the art without departing from the scope of the invention. Therefore, although the present invention has been described in greater detail by the above embodiments, the present invention is not limited to the above embodiments, and may include other equivalent embodiments without departing from the spirit of the present invention, and the scope of the present invention is determined by the scope of the appended claims.

Claims

1. A method for loading a collection of programs, comprising:

the client starts the target item based on the target plug-in sub-program set.

2. The method of claim 1, after the loading the set of target plug-in sub-programs, further comprising:

the client loads a project starting subprogram set in a project engineering program set based on the program loading hook file;

the client starts the target item based on the target plug-in sub program set, and the method comprises the following steps:

the client launches the target item based on the set of target plug-ins and the set of item promoter programs.

3. The method of claim 2, wherein the project promoter sequence set comprises a basic sub sequence set for starting the target project, or wherein the project promoter sequence set comprises a common sub sequence set and a basic sub sequence set for starting the target project, wherein the common sub sequence set comprises a sub sequence set in which a calling frequency of the project engineering sequence set reaches a preset frequency threshold and/or a number of terminals calling the sub sequence set reaches a preset number threshold.

4. The method of claim 2, further comprising:

the client stores a project starting subprogram set in a first storage space of a target terminal for operating the target project;

the client loads a project starting subprogram set in a project engineering program set based on the program loading hook file, and the method comprises the following steps:

and the client loads a project starting subprogram set in the project engineering program set from the first storage space based on the program loading hook file.

5. The method of claim 1, after the client launches the target item based on the set of target plug-in sub-programs, further comprising:

and the client displays a login interface of the target project, receives login information input by a target user on the login interface, and operates the target project based on the login information.

6. The method of claim 5, wherein the client runs the target item based on the login information, comprising:

the client side sends the login information and the current behavior data of the target user to an edge server based on the program loading hook file, so that the edge server determines the information to be loaded of the sub program set to be loaded corresponding to the target user based on the login information and the current behavior data;

the client receives the information to be loaded of the sub program set to be loaded, which is fed back by the edge server, and loads the sub program set to be loaded based on the information to be loaded;

and the client runs the target project based on the set of sub programs to be loaded.

7. The method of claim 6, wherein the edge server determining information to be loaded for a set of sub-programs to be loaded corresponding to the target user based on the login information and the current behavior data comprises:

the edge server acquires first historical behavior data of the target user based on the login information;

if the first historical behavior data is obtained, determining to-be-loaded information of a to-be-loaded sub-program set corresponding to the target user based on the current behavior data and the historical behavior data;

and if the edge server does not acquire the first historical behavior data, determining a reference user based on the login information, acquiring second historical behavior data of the reference user, and determining information to be loaded of the sub program set to be loaded corresponding to the target user based on the current behavior data and the second historical behavior data.

8. An assembly loading system, comprising a client, wherein the client comprises:

9. An electronic device, characterized in that the electronic device comprises:

one or more processors;

a storage device for storing one or more programs,

when executed by the one or more processors, cause the one or more processors to implement the assembly loading method of any one of claims 1-6.

10. A computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, carries out the program set loading method of any one of claims 1 to 6.