Hotspot code determination method, device, server and storage medium

Abstract

The present application discloses a hotspot code determination method, device, server and storage medium, and relates to the field of computer technology. The method comprises: obtaining multiple active components of an application, respectively obtaining the jump paths corresponding to each of the multiple active components, obtaining multiple jump paths, obtaining the weight corresponding to each of the multiple jump paths, determining the hotspot path according to the weight corresponding to each jump path, and determining the code related to the hotspot path as the hotspot code. The hotspot code determination method, device, server and storage medium provided in the embodiment of the present application determine the hotspot path by obtaining the weights corresponding to the jump paths corresponding to the various active components of the application, and determine the code related to the hotspot path as the hotspot code, thereby improving the accuracy of hotspot code determination and achieving the purpose of optimizing application performance.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and more specifically, to a hotspot code determination method, device, server and storage medium. Background Art

[0002] Electronic devices, such as tablet computers and smart terminals, have become one of the most commonly used consumer electronic products in people's daily lives. People usually install various applications in electronic devices to meet different needs. In the use of applications, frequently used methods or codes of the application are usually used as hot code, and the hot code is pre-compiled into binary machine code. The compiled binary machine code can be used to be directly executed by the processor when the application is run next time, thereby improving the running speed of the application. However, the current method for determining hot code is fixed and depends on the real-time running process. Therefore, it is not convenient to determine the hot code. Summary of the invention

[0003] In view of the above problems, the present application proposes a hotspot code determination method, device, server and storage medium to solve the above problems.

[0004] In a first aspect, an embodiment of the present application provides a hotspot method determination method, the method comprising: obtaining multiple active components of an application; respectively obtaining the jump paths corresponding to each of the multiple active components to obtain multiple jump paths; obtaining the weight corresponding to each of the multiple jump paths; determining the hotspot path according to the weight corresponding to each jump path, and determining the code related to the hotspot path as the hotspot code.

[0005] In the second aspect, an embodiment of the present application provides a hotspot code determination device, which includes: an active component acquisition module, used to acquire multiple active components of an application; a jump path acquisition module, used to respectively acquire the jump paths corresponding to each of the multiple active components, and obtain multiple jump paths; a weight acquisition module, used to acquire the weight corresponding to each of the multiple jump paths; a hotspot code determination module, used to determine the hotspot path according to the weight corresponding to each jump path, and determine the code related to the hotspot path as the hotspot code.

[0006] In a third aspect, an embodiment of the present application provides a server, comprising a memory and a processor, wherein the memory is coupled to the processor, the memory stores instructions, and when the instructions are executed by the processor, the processor executes the above method.

[0007] In a fourth aspect, an embodiment of the present application provides a computer-readable storage medium, in which a program code is stored, and the program code can be called by a processor to execute the above method.

[0008] The hotspot code determination method, device, server and storage medium provided in the embodiments of the present application obtain multiple active components of an application, respectively obtain the jump paths corresponding to each of the multiple active components, obtain multiple jump paths, obtain the weights corresponding to each of the multiple jump paths, determine the hotspot path according to the weight corresponding to each jump path, and determine the code related to the hotspot path as the hotspot code, thereby determining the hotspot path by obtaining the weights corresponding to the jump paths corresponding to the various active components of the application, and determining the code related to the hotspot path as the hotspot code, thereby improving the accuracy of hotspot code determination and achieving the purpose of optimizing application performance. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings required for use in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For those skilled in the art, other drawings can be obtained based on these drawings without paying any creative work.

[0010] Figure 1 A schematic diagram of an application environment that can be used for the hotspot code determination method provided in an embodiment of the present application is shown;

[0011] Figure 2 A schematic diagram showing another application environment that can be used for the hotspot code determination method provided in the embodiment of the present application is shown;

[0012] Figure 3 A schematic diagram of a hotspot code determination method provided by an embodiment of the present application is shown;

[0013] Figure 4 A jump relationship diagram of active components of an application provided by an embodiment of the present application is shown;

[0014] Figure 5 An adjacency linked list diagram of active components of an application provided by an embodiment of the present application is shown;

[0015] Figure 6 A schematic diagram of a hotspot code determination method provided by another embodiment of the present application is shown;

[0016] Figure 7 A schematic diagram of a hotspot code determination method provided in another embodiment of the present application is shown;

[0017] Figure 8 This application shows Figure 7 The flowchart of step S330 of the hotspot code determination method shown;

[0018] Fig. 9 A schematic diagram of a hotspot code determination method provided by another embodiment of the present application is shown;

[0019] Fig.10 A schematic diagram showing a flow chart of a hotspot code determination method provided by yet another embodiment of the present application;

[0020] Fig.11 A module block diagram of a hotspot code determination device provided in an embodiment of the present application is shown;

[0021] Fig.12 A block diagram of a server for executing a hotspot code determination method according to an embodiment of the present application is shown;

[0022] Fig.13 A storage unit for storing or carrying program codes for implementing the hotspot code determination method according to an embodiment of the present application is shown. DETAILED DESCRIPTION

[0023] In order to enable those skilled in the art to better understand the solution of the present application, the technical solution in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application.

[0024] Java runs on the Java virtual machine and runs in an interpreted execution mode. The interpreter translates the bytecodes into machine codes one by one. The features are that it can be executed immediately and saves memory, but the execution efficiency is relatively low. When the virtual machine finds that a method or code block is running very frequently, it will identify these codes as "hot code". In order to improve the execution efficiency of hot code, the frequently executed code can be translated into machine code, and it can be directly executed without interpretation the next time it is executed.

[0025] There are two main ways to determine hot code: one is hot spot detection based on sampling. The virtual machine using this method will periodically check the top of each thread's stack. If a certain code is found to appear frequently at the top of the stack, it is a hot code; the other is hot spot detection based on counters. The virtual machine using this method establishes a counter for each code and counts the number of times the code is executed. If the number of executions exceeds a certain threshold, it is considered a hot code. However, the current solution is aimed at the performance of Java programs when they are executed in the virtual machine, specifically the number of times a certain code or a certain code block is executed in the virtual machine, which depends on the real-time running process.

[0026] In response to the above problems, the inventor has made a long-term discovery and research, and proposed the hotspot code determination method, device, server and storage medium provided in the embodiments of the present application, which determines the hotspot path by obtaining the weights corresponding to the jump paths corresponding to the various active components of the application, and determines the code related to the hotspot path as the hotspot code, thereby improving the accuracy of hotspot code determination and achieving the purpose of optimizing application performance. Among them, the specific hotspot code determination method is described in detail in the subsequent embodiments.

[0027] The following is a description of an environment diagram that can be used for the hotspot code determination method provided in an embodiment of the present application.

[0028] See also Figure 1 , Figure 1 A schematic diagram of an application scenario provided by an embodiment of the present application is shown, and the application scenario includes: an electronic device 200 and a server 100. The electronic device 200 communicates with the server 100 through a network. The electronic device 200 can interact with the server 100 to obtain installation files, configuration files, etc. of an application from the server 100, or send multiple active components of an application to the server 100.

[0029] See also Figure 2 , Figure 2 Another schematic diagram of an application scenario provided by an embodiment of the present application is shown, and the server 100 may include a first server 110 and a second server 120. That is, the application scenario includes: an electronic device 200, a first server 110, and a second server 120. Among them, data is exchanged between the electronic device 200 and the first server 110, and data can also be exchanged between the first server 110 and the second server 120. The first server 110 can be used to process the request of the electronic device 200 and receive multiple active components of the application of the electronic device 200. The second server 120 can be used to store and manage the installation files, configuration files, and other files of the application. When the electronic device 200 obtains the file of the application from the first server 110, the first server 110 can obtain the file of the application from the second server 120, for example, obtain the installation file, the configuration file, etc., and send the file of the application to the electronic device 200. When the electronic device 200 sends multiple active components of the uploaded application, the first server 110 can receive the multiple active components of the application uploaded by the electronic device 200, and upload the multiple active components of the application to the second server 200.

[0030] Of course, the server 100 may also include other servers. For example, a third server may be included, which may be used to collect multiple active components of an application from a user's electronic device and transmit the collected multiple active components of the application to the second server 200 for sorting and storage, etc.; for another example, the application installation system may also include a fourth server, which may be used to store and manage the installation files of the application, etc. In this case, the second server 200 may store and manage the configuration files of the application, so that the installation files and configuration files of the application can be managed and stored separately.

[0031] In some embodiments, the electronic device 200 may be a smart phone, a tablet computer, an e-book, a smart watch or the like; the first server 110, the second server 120 and the like may be traditional servers or cloud servers, which are not limited here.

[0032] See also Figure 3 , Figure 3 The flowchart of a hotspot code determination method provided by an embodiment of the present application is shown. The hotspot code determination method is used to determine the hotspot path by obtaining the weights corresponding to the jump paths corresponding to the various active components of the application, and to determine the code related to the hotspot path as the hotspot code, thereby improving the accuracy of hotspot code determination and achieving the purpose of optimizing application performance. In a specific embodiment, the hotspot code determination method is applied to Fig.11 The hotspot method determining device 300 and the server 100 ( Fig.12 ). The following will take the server as an example to illustrate the specific process of this embodiment. Of course, it can be understood that the server used in this embodiment can be a cloud server or a traditional server, etc., which is not limited here. Figure 3 The process shown is described in detail, and the hotspot code determination method may specifically include the following steps:

[0033] Step S110: Acquire multiple active components of the application.

[0034] An activity component represents a single screen with a user interface, such as a Java window or frame. An Android activity component is a subclass of the ContextThemeWrapper class. An application may include one or more activity components. Optionally, in this embodiment, an application includes multiple activity components.

[0035] In some embodiments, the server can communicate with an electronic device installed with a client, and receive a message uploaded by the client carrying multiple active components of the application, and the server analyzes the message uploaded by the client to obtain the multiple active components of the application. In other embodiments, the server can obtain an installation package corresponding to the application, and obtain the multiple active components of the application based on the analysis of the installation package. Of course, in this embodiment, the server can also obtain multiple active components of the application in other ways, which will not be repeated here.

[0036] Step S120: respectively obtain the jump paths corresponding to each of the multiple active components to obtain multiple jump paths.

[0037] In some implementations, after acquiring multiple active components, the server may respectively acquire the jump paths corresponding to each of the multiple active components, and collect the jump paths corresponding to each active component to obtain multiple jump paths.

[0038] The jump path corresponding to each active component can be understood as a jump path directly related to each active component, that is, the jump path corresponding to each active component can be understood as a jump path by which each active component can directly jump to other active components. For example, when an application includes active component 1, active component 2, active component 3 and active component 4, and active component 1 can jump to active component 2 through jump path 1, and can jump to active component 4 through jump path 4, active component 2 can jump to active component 3 through jump path 2, and active component 3 can jump to active component 4 through jump path 3, it can be determined that the jump path directly related to active component 1 includes jump path 1 and jump path 4, that is, it can be determined that the jump path corresponding to active component 1 includes jump path 1 and jump path 4; it can be determined that the jump path directly related to active component 2 includes jump path 1 and jump path 2, that is, it can be determined that the jump path corresponding to active component 2 includes jump path 1 and jump path 2; it can be determined that the jump path directly related to active component 3 includes jump path 2 and jump path 3, that is, it can be determined that the jump path corresponding to active component 3 includes jump path 2 and jump path 3; it can be determined that the jump path directly related to active component 4 includes jump path 3 and jump path 4, that is, it can be determined that the jump path corresponding to active component 4 includes jump path 3 and jump path 4. Further, jump path 1 and jump path 4 corresponding to active component 1, jump path 1 and jump path 2 corresponding to active component 2, jump path 2 and jump path 3 corresponding to active component 3, and jump path 3 and jump path 4 corresponding to active component 4 are collected to obtain multiple jump paths including: jump path 1, jump path 2, jump path 3 and jump path 4.

[0039] Among them, the jump path corresponding to each active component can be understood as the jump path between each two adjacent active components. For example, when the application includes active component 1, active component 2, active component 3 and active component 4, and active component 1 is adjacent to active component 2 and active component 4, active component 2 is adjacent to active component 1 and active component 3, active component 3 is adjacent to active component 2 and active component 4, and active component 4 is adjacent to active component 3 and active component 1, then the jump path corresponding to active component 1 includes jump path 1 between active component 1 and active component 2 and jump path 4 between active component 1 and active component 4; the jump path corresponding to active component 2 includes jump path 1 between active component 2 and active component 1 and jump path 2 between active component 2 and active component 3; the jump path corresponding to active component 3 includes jump path 2 between active component 3 and active component 2 and jump path 3 between active component 3 and active component 4; the jump path corresponding to active component 4 includes jump path 3 between active component 4 and active component 3 and jump path 4 between active component 4 and active component 3. Further, the jump path 1 between active component 1 and active component 2, the jump path 2 between active component 2 and active component 3, the jump path 3 between active component 3 and active component 4, and the jump path 4 between active component 4 and active component 1 are collected to obtain multiple jump paths including: jump path 1, jump path 2, jump path 3, and jump path 4.

[0040] Step S130: Obtain a weight corresponding to each jump path in the multiple jump paths.

[0041] In this embodiment, after obtaining multiple jump paths, the server can respectively obtain the weight corresponding to each jump path in the multiple jump paths. In some embodiments, the weight corresponding to each jump path in the multiple jump paths can be preset and stored in the server or stored locally in the electronic device. Therefore, after obtaining multiple jump paths, the server can directly read the weight corresponding to each jump path in the multiple jump paths from the server, or request the weight corresponding to each jump path in the multiple jump paths from the electronic device. In other embodiments, the weight corresponding to each jump path in the multiple jump paths can be obtained by the server according to the running parameters of the application after obtaining the multiple jump paths. In some embodiments, the acquisition according to the running parameters of the application can include: obtaining according to the number of jumps corresponding to each jump path, obtaining according to the number of openings corresponding to each active component, obtaining according to the functional description information of the application, etc., which is not limited here.

[0042] In some embodiments, when multiple jump paths include jump path 1, jump path 2, jump path 3 and jump path 4, the weights corresponding to jump path 1, jump path 2, jump path 3 and jump path 4 can be obtained respectively. For example, the weight corresponding to jump path 1 is 80%, the weight corresponding to jump path 2 is 70%, the weight corresponding to jump path 3 is 50%, the weight corresponding to jump path 4 is 20%, etc., which is not limited here.

[0043] Step S140: determining a hotspot path according to the weight corresponding to each jump path, and determining the code related to the hotspot path as the hotspot code.

[0044] In some embodiments, after obtaining the weight corresponding to each jump path in a plurality of jump paths, a hotspot path can be determined from the plurality of jump paths according to the weight corresponding to each jump path, and the code related to the hotspot path can be determined as the hotspot code, wherein the code related to the hotspot path can include all the codes used by the hotspot path, so that the hotspot code can be determined without relying on the operation of the application, thereby improving the flexibility and accuracy of the hotspot code determination.

[0045] In some implementations, determining a hotspot path according to the weight corresponding to each jump path, and determining the code associated with the hotspot path as a hotspot code may include: obtaining a hotspot path having a weight greater than a weight threshold from the multiple jump paths, and determining the code associated with the hotspot path as a hotspot code. That is, the server may pre-acquire and store a weight threshold, and the weight threshold is used as a basis for determining the weight corresponding to the jump path. Therefore, in this embodiment, after obtaining the weight corresponding to each jump path in the multiple jump paths, the weight corresponding to each jump path may be compared with the weight threshold to determine whether the weight corresponding to each jump path is greater than the weight threshold, wherein when the weight of the jump path is greater than the weight threshold, the jump path may be determined as a hotspot path, and the code associated with the jump path may be determined as a hotspot code.

[0046] For example, when multiple jump paths include jump path 1, jump path 2, jump path 3 and jump path 4, and the weight corresponding to jump path 1 is 80%, the weight corresponding to jump path 2 is 70%, the weight corresponding to jump path 3 is 50%, and the weight corresponding to jump path 4 is 20%, if the weight threshold is 65%, then since the weight corresponding to jump path 1 and the weight corresponding to jump path 2 are greater than the weight threshold, jump path 1 and jump path 2 can be determined as hot spots, and the code related to jump path 1 can be determined as hot spots, and the code related to jump path 2 can be determined as hot spots. Code.

[0047] In some embodiments, determining a hotspot path according to the weight corresponding to each jump path, and determining the code related to the hotspot path as the hotspot code may include: sorting the multiple jump paths in order from high to low according to the weight corresponding to each jump path in the multiple jump paths, and determining the jump path sorted before the specified sorting position as the hotspot path, and determining the code related to the hotspot path as the hotspot code. That is, the server can pre-acquire and store the specified sorting position, and the specified sorting position is used as the judgment basis for sorting the multiple jump paths. Therefore, in this embodiment, after obtaining the weight corresponding to each jump path in the multiple jump paths, the multiple jump paths can be sorted in order from high to low according to the weight to obtain the sorting position of each jump path in the multiple jump paths, and then the sorting position of each jump path is compared with the specified sorting position to determine whether the sorting position of each jump path is before the specified sorting position, wherein when the sorting position of the jump path is before the specified sorting position, the jump path can be determined as a hotspot path, and the code related to the jump path can be determined as a hotspot code.

[0048] For example, when multiple jump paths include jump path 1, jump path 2, jump path 3 and jump path 4, and the weight corresponding to jump path 1 is 80%, the weight corresponding to jump path 2 is 70%, the weight corresponding to jump path 3 is 50%, and the weight corresponding to jump path 4 is 20%, if the sorting position 3 of the specified sorting position is specified, then after sorting the multiple jump paths in order from high to low weights, the sorting positions of jump path 1 and jump path 2 are before the specified sorting position, jump path 1 and jump path 2 can be determined as hot spots, and the code related to jump path 1 can be determined as hot spots, and the code related to jump path 2 can be determined as hot spots. Code.

[0049] In some implementations, after obtaining multiple active components and multiple jump paths of an application, G(V, E) may be created based on the multiple active components and the multiple jump paths, where V represents a set of multiple active components, E represents a set of multiple jump paths, and G represents a graph composed of multiple active components and multiple jump paths. Figure 4As shown in the figure, 0: main represents Activity 0, 1: A represents Activity 1, 2: B represents Activity 2, 3: C represents Activity 3, and 4: D represents Activity 4. Among them, vertex 0 represents the main interface of the application, Main Activity, which can be clicked to jump to Activity 1 and Activity 2, Activity 1 can be clicked to jump to Activity 0 and Activity 3, Activity 2 can be clicked to jump to Activity 0 and Activity 4, Activity 3 can be clicked to jump to Activity 1 and Activity 4, and Activity 4 can be clicked to jump to Activity 2 and Activity 3. Based on G(V, E) with Activity as the vertex, we can get the following: Figure 5 The linked list shown in Figure 5 In the example, 0 represents Activity 0, 1 represents Activity 1, 2 represents Activity 2, 3 represents Activity 3, and 4 represents Activity 4.

[0050] In some implementations, a jump state graph with Activity as the vertex is constructed, and the weight information of the edges connecting different Activity vertices can be reused after the application is upgraded to improve the mining efficiency of hotspot path code information. Specifically, the hotspot path information of Activity is reused here. Generally speaking, after the application is upgraded, the jump paths between the activities of the application interface are roughly the same, that is, the jump relationship between the interfaces is likely to remain unchanged. After the upgrade, the hotspot information after the new version can be quickly found based on this jump relationship.

[0051] A hotspot code determination method provided by an embodiment of the present application obtains multiple active components of an application, respectively obtains jump paths corresponding to each of the multiple active components, obtains multiple jump paths, obtains weights corresponding to each of the multiple jump paths, determines the hotspot path according to the weight corresponding to each jump path, and determines the code related to the hotspot path as the hotspot code, thereby determining the hotspot path by obtaining the weights corresponding to the jump paths corresponding to the various active components of the application, and determining the code related to the hotspot path as the hotspot code, thereby improving the accuracy of hotspot code determination and achieving the purpose of optimizing application performance.

[0052] See also Figure 6 , Figure 6 A flow chart of a method for determining a hotspot code according to another embodiment of the present application is shown. The method is applied to the above server. Figure 6 The process shown is described in detail, and the hotspot code determination method may specifically include the following steps:

[0053] Step S210: Acquire multiple active components of the application.

[0054] Step S220: respectively obtain the jump paths corresponding to each of the multiple active components to obtain multiple jump paths.

[0055] Step S230: Obtain a weight corresponding to each jump path in the multiple jump paths.

[0056] Step S240: acquiring a hotspot path having a weight greater than a weight threshold from the multiple jump paths, and determining a code related to the hotspot path as a hotspot code.

[0057] Among them, the specific description of steps S210 to S240 can be found in steps S210 to S240, which will not be repeated here.

[0058] Step S250: determining a main interface active component from the multiple active components.

[0059] In this embodiment, after obtaining multiple activity components, the main interface activity component (Main Activity) can be determined from the multiple activity components. In some implementations, multiple activity components can be pre-set to correspond to multiple identifiers one by one. Then, after obtaining multiple activity components, the identifiers corresponding to each of the multiple activity components can be obtained respectively, and the identifiers can be identified to obtain the identifier for identifying the main activity interface from the multiple identifiers, and the activity interface corresponding to the identifier is determined as the main interface activity interface. For example, the multiple activity components include the main interface activity component, the first other activity component, and the second other activity component, and the main interface activity component corresponds to identifier A, the first other activity component corresponds to identifier B, and the second other activity component corresponds to identifier C, then multiple identifiers can be obtained, and the activity component corresponding to identifier A is determined as the main interface activity component.

[0060] Step S260: obtaining a startup path from the start of the application to the end of the creation of the main interface active component, determining the startup path as a hotspot path, and determining the code related to the startup path as a hotspot code.

[0061] In some embodiments, the startup of an application is mainly divided into two parts, one is the system creation process, and the other is the application startup, wherein the system creation process is completed by the system itself and is related to the system performance. In this embodiment, the main purpose is to record the code related to the startup of the application, so that the startup path from the start of the application startup to the end of the creation of the main interface activity component can be obtained, that is, the startup path from the start of the on Create execution of the Application to the end of the creation of the Main Activity of the application can be obtained, which mainly includes the creation of the Activity, loading the layout, laying out the screen, and initial drawing, etc. In some embodiments, after obtaining the startup path, the startup path can be determined as a hotspot path, and the code related to the startup path can be determined as a hotspot code, wherein the code related to the startup path can include all the codes used in the startup path, so that the hotspot code can be determined without relying on the operation of the application, so as to improve the flexibility and accuracy of the hotspot code determination.

[0062] Step S270: Generate a configuration file including the hotspot code.

[0063] In some implementations, after determining the hotspot code, a profile configuration file including the hotspot code may be generated, so that the hotspot code is recorded through the configuration file and formed into a format that can be sent to the client to facilitate the distribution of the hotspot code.

[0064] Step S280: Send the configuration file to the client, where the configuration file is used to instruct the client to precompile the hotspot code.

[0065] In some embodiments, after the configuration file is generated, the configuration file can be sent to the client via a wired network or a wireless network to instruct the client to pre-compile the hotspot code in the configuration file, for example, instruct the client to pre-compile the hotspot code in the configuration file through JIT (Just-In-Time Compiler) to optimize the performance of the application.

[0066] As a method, the configuration file can be a configuration file that records the index or identifier of the hotspot code, that is, after determining the hotspot code, an index or identifier corresponding to the hotspot code can be generated, and then based on the index or identifier corresponding to the hotspot code, a configuration file including the index or identifier corresponding to the hotspot code is generated. In some embodiments, after generating a configuration file including an index or identifier corresponding to the hotspot code, the server can send the configuration file and the installation file together to the client, wherein the installation file includes the hotspot code and the non-hotspot code. After receiving the configuration file and the installation file, the client can search for the hotspot code corresponding to the index or identifier from the installation file based on the index or identifier in the push configuration file, and pre-compile the found hotspot code through AOT.

[0067] Another embodiment of the present application provides a method for determining hotspot codes, which obtains multiple active components of an application, obtains jump paths corresponding to each of the multiple active components, obtains multiple jump paths, obtains weights corresponding to each of the multiple jump paths, obtains hotspot paths with weights greater than a weight threshold from the multiple jump paths, and determines the code associated with the hotspot path as the hotspot code. Determine the main interface active component from the multiple active components, obtain the startup path from the start of the application to the end of the creation of the main interface active component, determine the startup path as the hotspot path, and determine the code associated with the startup path as the hotspot code. Generate a configuration file including the hotspot code, send the configuration file to the client, and the configuration file is used to instruct the client to pre-compile the hotspot code. Compared to Figure 3 The hotspot code determination method shown in this embodiment also determines the jump path as a hotspot path when the weight of the jump path is greater than the weight threshold to improve the accuracy of the hotspot path determination, and the present embodiment also determines the startup path of the application as the hotspot path to improve the startup speed of the application. In addition, the present embodiment also generates a configuration file including the hotspot code and sends it to the client to compile the hotspot code in advance to improve the performance of the application.

[0068] See also Figure 7 , Figure 7 A schematic diagram of a hotspot code determination method provided by another embodiment of the present application is shown. The method is applied to the above server. Figure 7 The process shown is described in detail, and the hotspot code determination method may specifically include the following steps:

[0069] Step S310: Acquire multiple active components of the application.

[0070] Step S320: respectively obtain the jump paths corresponding to each of the multiple active components to obtain multiple jump paths.

[0071] For the detailed description of step S310 to step S320, please refer to step S110 to step S120, which will not be repeated here.

[0072] Step S330: Obtain the number of jumps corresponding to each jump path in the multiple jump paths.

[0073] In some implementations, after obtaining multiple jump paths, the number of jumps corresponding to each of the multiple jump paths can be obtained respectively. In the process of using the application, the jumps of each jump path can be recorded, and the number of jumps of each jump path can be accumulated, and the number of jumps of the accumulated jump path can be determined as the number of jumps corresponding to the jump path.

[0074] For example, when the multiple jump paths include jump path 1, jump path 2, jump path 3 and jump path 4, the jump times corresponding to jump path 1, the jump times corresponding to jump path 2, the jump times corresponding to jump path 3 and the jump times corresponding to jump path 4 can be obtained respectively. Among them, jumping from active component 1 to active component 4 or from active component 4 to active component 1 can be recorded as the jump times of jump path 4, and jumping from active component 1 to active component 2 or from active component 2 to active component 1 can be recorded as the jump times of jump path 1, which will not be repeated here.

[0075] See also Figure 8 , Figure 8 This application shows Figure 7 The flowchart of step S330 of the hotspot code determination method shown in FIG. Figure 8 The process shown is described in detail, and the method may specifically include the following steps:

[0076] Step S331: respectively obtain the opening times of each of the multiple active components.

[0077] In some implementations, the number of times each of the multiple active components is opened can be obtained separately. In the process of using the application, the opening of each active component can be recorded, and the number of times each active component is opened can be accumulated, and the accumulated number of times the active component is opened can be determined as the number of times the active component is opened. For example, when the multiple active components include active component 1, active component 2, active component 3, and active component 4, the number of times the active component 1 is opened, the number of times the active component 2 is opened, the number of times the active component 3 is opened, and the number of times the active component 4 is opened can be obtained separately.

[0078] Step S332: Based on the opening times of each of the multiple active components, the jump times corresponding to each of the multiple jump paths are obtained.

[0079] In some implementations, after obtaining the number of times each of the multiple active components is opened, the number of jumps corresponding to each of the multiple jump paths can be obtained based on the number of times each of the multiple active components is opened. In this embodiment, the more times an active component is opened, the more frequently an application jumps to the active component, and the more jumps the jump path corresponding to the active component has; the fewer times an active component is opened, the more rarely an application jumps to the active component, and the fewer jumps the jump path corresponding to the active component has.

[0080] In some implementations, the number of jumps corresponding to each active component can be estimated based on the number of times each active component is opened, or the number of jumps corresponding to each active component can be calculated based on the number of times each active component is opened, which is not limited here.

[0081] Step S340: based on the number of jumps corresponding to each of the multiple jump paths, obtain a weight corresponding to each of the multiple jump paths.

[0082] In some implementations, after determining the number of jumps corresponding to each of the multiple jump paths, the weight corresponding to each of the multiple jump paths can be obtained based on the number of jumps corresponding to each of the multiple jump paths. In this embodiment, the more jumps corresponding to a jump path, the more frequently the jump path is used by the application program, and the more likely the jump path is to be a hotspot path, and the greater the weight corresponding to the jump path, and the fewer jumps corresponding to the jump path, the more rarely the jump path is used by the application program, and the less likely the jump path is to be a hotspot path, and the smaller the weight corresponding to the jump path.

[0083] For example, when the number of jumps corresponding to jump path 1 is 50, the number of jumps corresponding to jump path 2 is 20, the number of jumps corresponding to jump path 3 is 10, and the number of jumps corresponding to jump path 4 is 70, then it can be set as: the weight corresponding to jump path 4 > the weight corresponding to jump path 1 > the weight corresponding to jump path 2 > the weight corresponding to jump path 3.

[0084] Step S350: acquiring a hotspot path whose weight is greater than a weight threshold from the multiple jump paths, and determining the code related to the hotspot path as the hotspot code.

[0085] For the detailed description of step S350, please refer to step S140, which will not be repeated here.

[0086] Another embodiment of the present application provides a method for determining hotspot codes, which obtains multiple active components of an application, obtains jump paths corresponding to each of the multiple active components, obtains multiple jump paths, obtains the number of jumps corresponding to each of the multiple jump paths, obtains the weight corresponding to each of the multiple jump paths based on the number of jumps corresponding to each of the multiple jump paths, obtains hotspot paths with weights greater than a weight threshold from the multiple jump paths, and determines the code related to the hotspot path as the hotspot code. Compared to Figure 3 The hotspot code determination method shown in the present embodiment also determines the jump path as a hotspot path when the weight of the jump path is greater than the weight threshold, so as to improve the accuracy of the hotspot path determination. In addition, the present embodiment also determines the weight corresponding to each jump path according to the number of jumps of each jump path, so as to improve the accuracy of the obtained weight.

[0087] See also Fig. 9 , Fig. 9 A schematic diagram of a hotspot code determination method provided by another embodiment of the present application is shown. The method is applied to the above server. Fig. 9 The process shown is described in detail, and the hotspot code determination method may specifically include the following steps:

[0088] Step S410: Acquire multiple active components of the application.

[0089] Step S420: respectively obtain the jump paths corresponding to each of the multiple active components to obtain multiple jump paths.

[0090] For the detailed description of step S410 to step S420, please refer to step S110 to step S120, which will not be repeated here.

[0091] Step S430: Acquire functional description information of the application.

[0092] In this embodiment, the functional description information of the application can be obtained. As one way, the functional description information of the application can be obtained through the "application information" or "application tag" of the application. As another way, the description of the application in the application store can be obtained, and the description of the application in the application store can be determined as the functional description information of the application. For example, the functional description information of WeChat includes: sending voice, text messages, pictures, etc.; sharing life moments in Moments; scanning; public accounts, etc.

[0093] Step S440: Determine the target activity component involved in the function description information from the multiple activity components.

[0094] In some embodiments, after obtaining the functional description information of the application, the active components involved in the functional description information can be determined from multiple active components, and the active components involved in the functional description information can be used as target active components. Among them, the number of target active components involved in the functional description information can be one or more, which is not limited here. For example, when the functional description information of the WeChat application includes scanning and sharing life moments with friends, the active component involved in scanning in the WeChat application can be determined as the target active component, and the active component involved in the WeChat application circle of friends can be determined as the target active component, etc., which is not limited here.

[0095] Step S450: Determine, from the multiple jump paths, a first jump path related to the target active component and a second jump path unrelated to the target active component.

[0096] In some embodiments, after determining the target active component, a jump path related to the target active component and a second jump path unrelated to the target active component can be determined from multiple jump paths, the jump path related to the active component can be determined as the first jump path, and the jump path unrelated to the active component can be determined as the second jump path.

[0097] For example, active components include active component 1, active component 2, active component 3 and active component 4, and jump paths include jump path 1, jump path 2, jump path 3 and jump path 4, wherein active component 1 is the target active component. Then, it can be known that jump path 1 and jump path 4 are related to active component 1, and jump path 1 and jump path 4 can be determined as the first jump path, and jump path 2 and jump path 3 are not related to active component 1, and jump path 2 and jump path 3 can be determined as the second jump path.

[0098] Step S460: Obtain a first weight corresponding to the first jump path, and obtain a second weight corresponding to the second jump path, wherein the first weight is greater than the second weight.

[0099] In some embodiments, after determining the first jump path and the second jump path, the first weight of the first jump path and the weight corresponding to the second jump path can be obtained, and the weight corresponding to the first jump path is used as the first weight, and the weight corresponding to the second jump path is used as the second weight. In this embodiment, the first weight is greater than the second weight, for example, the first weight is 80%, the second weight is 20%, and for another example, the first weight is 90%, the second weight is 10%, etc. It can be understood that the target activity component related to the functional description information is the main functional interface of the application, and the first jump path related to the main functional interface is the main jump path. Therefore, a larger weight can be assigned to the main jump path, so that the code related to the functional description information is identified as a hotspot code.

[0100] Step S470: acquiring a hotspot path having a weight greater than a weight threshold from the multiple jump paths, and determining a code related to the hotspot path as a hotspot code.

[0101] For the detailed description of step S470, please refer to step S140, which will not be repeated here.

[0102] Another embodiment of the present application provides a method for determining hotspot codes, which obtains multiple active components of an application, obtains the jump paths corresponding to each of the multiple active components, obtains multiple jump paths, obtains functional description group information of multiple applications, determines the target active components involved in the functional description information from the multiple active components, determines a first jump path related to the target active component and a second jump path unrelated to the target active component from the multiple jump paths, obtains a first weight corresponding to the first jump path, and obtains a second weight corresponding to the second jump path, wherein the first weight is greater than the second weight, obtains a hotspot path having a weight greater than a weight threshold from the multiple jump paths, and determines the code related to the hotspot path as the hotspot code. Compared to Figure 3 The hotspot code determination method shown in this embodiment also determines the jump path as a hotspot path when the weight of the jump path is greater than the weight threshold to improve the accuracy of the hotspot path determination. In addition, this embodiment also determines the weight corresponding to each jump path based on the functional description information of the application to improve the accuracy of the obtained weight.

[0103] See also Fig.10 , Fig.10 A flowchart of a method for determining a hotspot code provided by another embodiment of the present application is shown. The method is applied to the above server. Fig.10 The process shown is described in detail, and the hotspot code determination method may specifically include the following steps:

[0104] Step S510: Acquire multiple active components of the application.

[0105] Step S520: respectively obtain the jump paths corresponding to each of the multiple active components to obtain multiple jump paths.

[0106] For the detailed description of step S510 to step S520, please refer to step S110 to step S120, which will not be repeated here.

[0107] Step S530: Obtain a user portrait of the target user.

[0108] In this embodiment, the server can obtain the user portrait of the target user corresponding to the client to be pushed. For example, the client can log in with a user identity authentication identifier (Identity document, ID), then the user corresponding to the user ID logged in by the client can be determined as the target user. For another example, the electronic device corresponding to the client can record a biometric unlocking password, for example, the electronic device can record a fingerprint unlocking password, a face unlocking password, an iris unlocking password, etc., then the user corresponding to the biometric unlocking password recorded by the electronic device can be determined as the target user.

[0109] In some implementations, the user portrait of the target user may include the target user's age, gender, interests, hobbies, habits, etc., which are not limited here.

[0110] Step S540: determining the jump probability of the target user for each of the multiple jump paths based on the user portrait.

[0111] In some embodiments, after obtaining the user portrait of the target user, the jump probability of the target user for each of the multiple jump paths can be determined based on the user portrait of the target user. In some embodiments, after obtaining the user portrait of the target user, the interests and hobbies of the target user can be obtained based on the user portrait of the target user, and the jump probability of the target user for each of the multiple jump paths can be determined based on the interests and hobbies of the target user. For example, based on the interests and hobbies of the target user, the jump probability of the target user for the jump paths related to Moments and Scan QR Code can be determined, etc., which is not limited here.

[0112] Step S550: based on the jump probability of the target user for each of the multiple jump paths, obtaining a weight corresponding to each of the multiple jump paths.

[0113] In some embodiments, after determining the jump probability corresponding to each jump path in the multiple jump paths, the weight corresponding to each jump path in the multiple jump paths can be obtained based on the jump probability corresponding to each jump path in the multiple jump paths. In this embodiment, the higher the jump probability corresponding to the jump path, the greater the probability that the application uses the jump path, and the more likely the jump path is to be a hotspot path, the greater the weight corresponding to the jump path, and the lower the jump probability corresponding to the jump path, the smaller the probability that the application uses the jump path, and the less likely the jump path is to be a hotspot path, the smaller the weight corresponding to the jump path.

[0114] For example, when the jump probability corresponding to jump path 1 is 80%, the jump probability corresponding to jump path 2 is 40%, the jump probability corresponding to jump path 3 is 20%, and the jump probability corresponding to jump path 4 is 90%, it can be set as: the weight corresponding to jump path 4 > the weight corresponding to jump path 1 > the weight corresponding to jump path 2 > the weight corresponding to jump path 3.

[0115] Taking WeChat as an example, some users may only use the chat and public account functions, while some users may only use the chat and Moments functions. Then, by using the user portrait of the target user, we can find the jump path corresponding to the activity component corresponding to the usage habits, map it to the code execution path, and record it as the hotspot code. The hotspot code information is recorded in a profile configuration file. According to the user portrait, when the target user downloads or updates the WeChat application, the hotspot information is distributed, and then the user client compiles the application in advance based on this part of information to achieve performance improvement.

[0116] Step S560: Acquire a hotspot path whose weight is greater than a weight threshold from the multiple jump paths, and determine the code related to the hotspot path as the hotspot code.

[0117] For the detailed description of step S560, please refer to step S140, which will not be repeated here.

[0118] The present application provides a method for determining hotspot codes in another embodiment, which obtains multiple active components of an application, obtains the jump paths corresponding to each of the multiple active components, obtains multiple jump paths, obtains a user portrait of a target user, determines the jump probability of the target user for each of the multiple jump paths based on the user portrait, obtains the weight corresponding to each of the multiple jump paths based on the jump probability of the target user for each of the multiple jump paths, obtains a hotspot path whose weight is greater than a weight threshold from the multiple jump paths, and determines the code related to the hotspot path as a hotspot code. Compared to Figure 3The hotspot code determination method shown in the present embodiment also determines the jump path as a hotspot path when the weight of the jump path is greater than the weight threshold, so as to improve the accuracy of the hotspot path determination. In addition, the present embodiment also determines the weight corresponding to each jump path according to the user portrait of the target user, so as to improve the accuracy of the obtained weight.

[0119] See also Fig.11 , Fig.11 The module block diagram of the hotspot code determination device 300 provided in the embodiment of the present application is shown. The hotspot code determination device 300 is applied to the above server. Fig.11 The hotspot code determination device 300 includes: an activity component acquisition module 310, a jump path acquisition module 320, a weight acquisition module 330 and a hotspot code determination module 340, wherein:

[0120] The activity component acquisition module 310 is used to acquire multiple activity components of the application.

[0121] The jump path obtaining module 320 is used to respectively obtain the jump path corresponding to each of the multiple active components to obtain multiple jump paths.

[0122] The weight acquisition module 330 is used to acquire the weight corresponding to each jump path in the multiple jump paths.

[0123] Furthermore, the weight acquisition module 330 includes: a jump count acquisition submodule and a first weight acquisition submodule, wherein:

[0124] The jump number acquisition submodule is used to acquire the jump number corresponding to each jump path in the multiple jump paths.

[0125] Furthermore, the jump times acquisition submodule includes: an opening times acquisition unit and a jump times acquisition unit, wherein

[0126] The opening number acquisition unit is used to respectively acquire the opening number of each active component in the multiple active components.

[0127] The jump count acquisition unit is used to acquire the jump count corresponding to each jump path in the multiple jump paths based on the opening count of each active component in the multiple active components.

[0128] The first weight acquisition submodule is used to acquire the weight corresponding to each of the multiple jump paths based on the number of jumps corresponding to each of the multiple jump paths.

[0129] Furthermore, the weight acquisition module 330 includes: a function description information acquisition submodule, a target activity component determination submodule, a jump path determination submodule and a second weight acquisition submodule, wherein:

[0130] The function description information acquisition submodule is used to acquire the function description information of the application.

[0131] The target activity component determination submodule is used to determine the target activity component involved in the function description information from the multiple activity components.

[0132] The jump path determination submodule is used to determine a first jump path related to the target active component and a second jump path unrelated to the target active component from the multiple jump paths.

[0133] The second weight acquisition submodule is used to acquire a first weight corresponding to the first jump path, and to acquire a second weight corresponding to the second jump path, wherein the first weight is greater than the second weight.

[0134] Furthermore, the weight acquisition module 330 includes: a user portrait acquisition submodule, a jump probability determination submodule and a third weight acquisition submodule, wherein:

[0135] The user portrait acquisition submodule is used to obtain the user portrait of the target user.

[0136] The jump probability determination submodule is used to determine the jump probability of the target user for each jump path in the multiple jump paths based on the user portrait.

[0137] The third weight acquisition submodule is used to acquire the weight corresponding to each of the multiple jump paths based on the jump probability of the target user for each of the multiple jump paths.

[0138] The hotspot code determination module 340 is used to determine a hotspot path according to the weight corresponding to each jump path, and determine the code related to the hotspot path as the hotspot code.

[0139] Furthermore, the hotspot code determination module 340 includes: a hotspot code determination submodule, wherein:

[0140] The hotspot code determination submodule is used to obtain a hotspot path whose weight is greater than a weight threshold from the multiple jump paths, and determine the code related to the hotspot path as the hotspot code.

[0141] Furthermore, the hotspot code determination device 300 includes: a main interface active component determination module and a startup path acquisition module, wherein:

[0142] The main interface active component determination module is used to determine the main interface active component from the multiple active components.

[0143] The startup path acquisition module is used to acquire the startup path from the start of the application to the end of the creation of the main interface active component, determine the startup path as a hotspot path, and determine the code related to the startup path as a hotspot code.

[0144] Furthermore, the hotspot code determination device 300 further includes: a configuration file generation module and a configuration file sending module, wherein:

[0145] The configuration file generation module is used to generate a configuration file including the hotspot code.

[0146] The configuration file sending module is used to send the configuration file to the client, and the configuration file is used to instruct the client to precompile the hotspot code.

[0147] Furthermore, the hotspot code determination device 300 further includes: a creation module, wherein:

[0148] A creation module is used to create G(V, E) based on the multiple active components and the multiple jump paths, wherein V represents a set of the multiple active components and E represents a set of the multiple jump paths.

[0149] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the above-described devices and modules can refer to the corresponding processes in the aforementioned method embodiments, and will not be repeated here.

[0150] In several embodiments provided in the present application, the coupling between modules may be electrical, mechanical or other forms of coupling.

[0151] In addition, each functional module in each embodiment of the present application can be integrated into a processing module, or each module can exist physically separately, or two or more modules can be integrated into one module. The above integrated modules can be implemented in the form of hardware or software functional modules.

[0152] See also Fig.12, which shows a structural block diagram of a server 100 provided in an embodiment of the present application. The server 100 may be a traditional server or a cloud server, etc. The server 100 in the present application may include one or more of the following components: a processor 130, a memory 140, and one or more application programs, wherein the one or more application programs may be stored in the memory 140 and configured to be executed by one or more processors 130, and the one or more programs are configured to execute the method described in the aforementioned method embodiment.

[0153] Among them, the processor 130 may include one or more processing cores. The processor 130 uses various interfaces and lines to connect various parts within the entire server 100, and executes various functions and processes data of the server 100 by running or executing instructions, programs, code sets or instruction sets stored in the memory 140, and calling data stored in the memory 140. Optionally, the processor 130 can be implemented in at least one hardware form of digital signal processing (Digital Signal Processing, DSP), field programmable gate array (Field-Programmable Gate Array, FPGA), and programmable logic array (Programmable Logic Array, PLA). The processor 110 can integrate one or a combination of a central processing unit (Central Processing Unit, CPU), a graphics processing unit (Graphics Processing Unit, GPU) and a modem. Among them, the CPU mainly processes the operating system, user interface and application programs; the GPU is responsible for rendering and drawing the content to be displayed; and the modem is used to process wireless communications. It can be understood that the above-mentioned modem may not be integrated into the processor 130, but may be implemented separately through a communication chip.

[0154] The memory 140 may include a random access memory (RAM) or a read-only memory (ROM). The memory 140 may be used to store instructions, programs, codes, code sets or instruction sets. The memory 140 may include a program storage area and a data storage area, wherein the program storage area may store instructions for implementing an operating system, instructions for implementing at least one function (such as a touch function, a sound playback function, an image playback function, etc.), instructions for implementing the following various method embodiments, etc. The data storage area may also store data (such as a phone book, audio and video data, chat record data) created by the server 100 during use.

[0155] See also Fig.13, which shows a structural block diagram of a computer-readable storage medium provided in an embodiment of the present application. The computer-readable medium 400 stores program codes, which can be called by a processor to execute the method described in the above method embodiment.

[0156] The computer readable storage medium 400 may be an electronic memory such as a flash memory, an EEPROM (electrically erasable programmable read-only memory), an EPROM, a hard disk, or a ROM. Optionally, the computer readable storage medium 400 includes a non-transitory computer-readable storage medium. The computer readable storage medium 400 has storage space for program code 410 that performs any method steps in the above method. These program codes can be read from or written to one or more computer program products. The program code 410 can be compressed, for example, in an appropriate form.

[0157] In summary, the hotspot code determination method, device, server and storage medium provided in the embodiments of the present application obtain multiple active components of an application, respectively obtain the jump paths corresponding to each of the multiple active components, obtain multiple jump paths, obtain the weights corresponding to each of the multiple jump paths, determine the hotspot path according to the weight corresponding to each jump path, and determine the code related to the hotspot path as the hotspot code, thereby determining the hotspot path by obtaining the weights corresponding to the jump paths corresponding to the various active components of the application, and determining the code related to the hotspot path as the hotspot code, thereby improving the accuracy of hotspot code determination and achieving the purpose of optimizing application performance.

[0158] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit it. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present application.

Claims

1. A method for determining a hotspot code, characterized in that: The method comprises: Get multiple active components of the application; Respectively acquiring a jump path corresponding to each of the multiple active components to obtain multiple jump paths, wherein the jump path corresponding to each active component refers to a jump path for each active component to directly jump to other active components; Obtaining a weight corresponding to each jump path in the multiple jump paths; Determine a hotspot path according to the weight corresponding to each jump path, and determine the code related to the hotspot path as the hotspot code; Generate a configuration file including the hotspot code; The configuration file is sent to the client, where the configuration file is used to instruct the client to precompile the hotspot code.

2. The method according to claim 1, characterized in that The step of determining a hotspot path according to a weight corresponding to each jump path, and determining a code related to the hotspot path as a hotspot code, includes: A hotspot path having a weight greater than a weight threshold is acquired from the multiple jump paths, and a code related to the hotspot path is determined as a hotspot code.

3. The method according to claim 1, characterized in that The method further comprises: Determine a main interface active component from the multiple active components; A startup path from the start of the application to the end of the creation of the main interface active component is obtained, the startup path is determined as a hotspot path, and the code related to the startup path is determined as a hotspot code.

4. The method according to claim 1, characterized in that: The obtaining a weight corresponding to each jump path in the plurality of jump paths includes: Obtaining the number of jumps corresponding to each jump path in the multiple jump paths; Based on the number of jumps corresponding to each of the multiple jump paths, a weight corresponding to each of the multiple jump paths is obtained.

5. The method according to claim 4, characterized in that The obtaining the number of jumps corresponding to each jump path in the plurality of jump paths includes: Respectively obtain the number of times each of the multiple activity components is opened; Based on the opening times of each of the multiple active components, the jump times corresponding to each of the multiple jump paths are obtained.

6. The method according to claim 1, characterized in that The obtaining a weight corresponding to each jump path in the plurality of jump paths includes: Obtaining functional description information of the application; Determine a target activity component involved in the function description information from the multiple activity components; Determine, from the plurality of jump paths, a first jump path related to the target active component and a second jump path unrelated to the target active component; A first weight corresponding to the first jump path is obtained, and a second weight corresponding to the second jump path is obtained, wherein the first weight is greater than the second weight.

7. The method according to claim 1, characterized in that The obtaining a weight corresponding to each jump path in the plurality of jump paths includes: Get the user profile of the target user; Determining a jump probability of the target user for each of the multiple jump paths based on the user portrait; Based on the jump probability of the target user for each of the multiple jump paths, a weight corresponding to each of the multiple jump paths is obtained.

8. A hotspot code determination device, characterized in that: The device comprises: An activity component acquisition module is used to acquire multiple activity components of an application; A jump path acquisition module, used to respectively acquire the jump path corresponding to each of the multiple active components to obtain multiple jump paths, wherein the jump path corresponding to each active component refers to a jump path for each active component to directly jump to other active components; A weight acquisition module, used to acquire a weight corresponding to each jump path in the multiple jump paths; A hot code determination module, used to determine a hot path according to the weight corresponding to each jump path, and determine the code related to the hot path as the hot code; A configuration file generating module, used to generate a configuration file including the hotspot code; The configuration file sending module is used to send the configuration file to the client, and the configuration file is used to instruct the client to precompile the hotspot code.

9. A server, characterized in that: The method comprises a memory and a processor, wherein the memory is coupled to the processor, the memory stores instructions, and when the instructions are executed by the processor, the processor executes the method according to any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores program codes, which can be called by a processor to execute the method according to any one of claims 1 to 7.

Images