CN116627521A

CN116627521A - Service module preloading method, skipping method, device and storage medium

Info

Publication number: CN116627521A
Application number: CN202210125917.9A
Authority: CN
Inventors: 滕睿
Original assignee: SF Technology Co Ltd
Current assignee: SF Technology Co Ltd
Priority date: 2022-02-10
Filing date: 2022-02-10
Publication date: 2023-08-22

Abstract

The application discloses a service module preloading method, a jump method, a device and a storage medium, wherein the service module preloading method comprises the following steps: acquiring a starting request of a target application; determining a plurality of service modules which need to be preloaded according to the starting request; loading a preloading file of each service module, and generating a primary interface of each service module according to the preloading file and the preloading information of each service module, which is predetermined; the original interfaces of the service modules are cached to a cache pool so as to realize the preloading of a plurality of service modules, and the cache pool is a preset cache resource pool for storing interface resources. When the page of the service module is entered in the embodiment of the application, the original interface of the service module can be directly obtained from the cache pool to display the page, so that the problem of white screen caused by waiting time of loading and rendering is avoided, and smooth and white-screen-free service module skip is realized.

Description

Service module preloading method, skipping method, device and storage medium

Technical Field

The present application relates to the field of communications technologies, and in particular, to a service module preloading method, a service module skipping device, and a storage medium.

Background

Along with the development of services, program codes and services are more and more in the development of many Application (APP) projects, and code management and collaborative development become difficult. However, due to the waiting time of loading and rendering when each service module is loaded, a white screen problem exists when the page of the service module is entered, and the user experience is affected.

Disclosure of Invention

The embodiment of the application provides a service module preloading method, a skipping method, a device and a storage medium, which can directly acquire a native interface of a service module from a cache pool to display the page when the page of the service module is entered, so that the problem of white screen caused by waiting time of loading and rendering is avoided, and smooth and white-screen-free skipping among the service modules is realized.

In one aspect, the present application provides a service module preloading method, where the service module preloading method includes:

acquiring a starting request of a target application;

determining a plurality of service modules which need to be preloaded according to the starting request;

Loading a preloading file of each service module in the plurality of service modules, and generating a native interface of each service module according to the preloading file and the preloading information of each service module, which is predetermined;

and caching the original interfaces of the service modules into a cache pool to realize the preloading of the service modules, wherein the cache pool is a preset cache resource pool for storing interface resources.

In some embodiments of the present application, the determining, according to the start request, a number of service modules that need to be preloaded includes:

determining a module name array corresponding to the target application according to the starting request, wherein the module name array is an array formed by service module names of a plurality of service modules which need to be preloaded in the target application;

and determining a plurality of business modules which need to be preloaded according to the module name array.

In some embodiments of the present application, the determining, according to the module name array, a number of service modules that need to be preloaded includes:

acquiring preset corresponding relations between names of all service modules and the service modules;

And determining a plurality of business modules which need to be preloaded according to the module name array and the corresponding relation.

In some embodiments of the present application, the pre-load file includes JS code for page presentation and interaction, and the generating a native interface of each business module according to the pre-load file and pre-determined pre-load information of each business module includes:

obtaining JS codes in the preloaded file;

and generating a primary interface of each business module according to the JS codes and the pre-determined pre-loading information of each business module.

In some embodiments of the present application, before the obtaining the start request of the target application, the method further includes:

acquiring a service module file set of the target application, wherein the service module file set is a file set formed by resource files of service modules in the target application;

and generating the preloading information of each service module according to the service module file set.

judging whether a main thread corresponding to a target application is idle or not according to the starting request;

If the main line Cheng Kongxian, a number of traffic modules that need to be preloaded are determined.

In some embodiments of the present application, the determining, according to the start request, a number of service modules that need to be preloaded further includes:

and loading and rendering a homepage service module of the target application according to the starting request.

In another aspect, the present application provides a service module pre-skipping method, where the service module pre-skipping method is applied to a service module preloaded by the service module preloading method in any one of the first aspects, where the service module pre-skipping method includes:

when a jump instruction for jumping to a target service module is received, acquiring a primary interface of the target service module from a cache pool;

and displaying the page of the target service module according to the original interface of the target service module and the preloading file of the target service module.

In some embodiments of the present application, before the acquiring the native interface of the target service module from the cache pool, the method further includes:

obtaining a cache mark in the cache pool, and determining whether a native interface of the target service module exists in the cache pool according to the cache mark;

And when the original interface of the target service module does not exist in the cache pool, generating the original interface of the target service module according to the pre-loading file of the target service module and pre-determined pre-loading information of the target service module.

In another aspect, the present application provides a service module preloading device, including:

the request acquisition module is used for acquiring a starting request of the target application;

the module determining unit is used for determining a plurality of service modules which need to be preloaded according to the starting request;

the interface generation unit is used for loading the preloading file of each service module in the plurality of service modules and generating a primary interface of each service module according to the preloading file and the preloading information of each service module, which is predetermined;

the preloading unit is used for caching the original interfaces of the service modules to a cache pool so as to preload the service modules, wherein the cache pool is a preset cache resource pool for storing interface resources.

In some embodiments of the application, the module determining unit is specifically configured to:

In some embodiments of the application, the module determining unit is specifically further configured to:

In some embodiments of the present application, the service module preloading device further includes:

and the homepage rendering unit is used for loading and rendering the homepage service module of the target application according to the starting request.

In some embodiments of the present application, the interface generating unit is specifically configured to:

Obtaining JS codes in the preloaded file;

the file acquisition unit is used for acquiring a service module file set of the target application, wherein the service module file set is a file set formed by resource files of service modules in the target application;

and the information generating unit is used for generating the preloading information of each service module according to the service module file set.

and the mark generation unit is used for generating cache marks corresponding to the service modules.

In some embodiments of the present application, the interface generating unit is specifically further configured to:

In another aspect, the present application provides a service module jumping apparatus, including:

The module jumping unit is used for acquiring a primary interface of the target service module from the cache pool when a jumping instruction for jumping to the target service module is received;

and the page display unit is used for displaying the page of the target service module according to the original interface of the target service module and the preloaded file of the target service module.

In some embodiments of the present application, the service module skipping apparatus further includes:

the mark acquisition unit is used for acquiring the cache mark in the cache pool and determining whether a native interface of the target service module exists in the cache pool according to the cache mark.

In another aspect, the present application also provides a computer apparatus, including:

one or more processors;

a memory; and

one or more applications, wherein the one or more applications are stored in the memory and are configured to be executed by the processor to implement the business module preloading method of any of the first aspects or to implement the business module skipping method of any of the second aspects.

In a sixth aspect, the present application also provides a computer readable storage medium having stored thereon a computer program, the computer program being loaded by a processor to perform the steps of the traffic module preloading method according to any of the first aspects or to perform the steps of the traffic module skipping method according to any of the second aspects.

The application determines a plurality of business modules to be preloaded according to the starting request, generates the original interfaces of each business module according to the preloading files of each business module in the plurality of business modules and the preloading information of each business module, and caches the original interfaces of each business module into the cache pool, when the business module page is entered, the original interfaces of the business modules can be directly obtained from the cache pool to display the page, thereby avoiding the problem of white screen caused by the waiting time of loading and rendering, and realizing smooth and non-white screen business module skip.

Drawings

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

Fig. 1 is a schematic view of a scenario of a service module preloading system provided in an embodiment of the present application;

FIG. 2 is a flow chart of an embodiment of a method for preloading a service module according to an embodiment of the present application;

Fig. 3 is a schematic flow chart of a specific embodiment of a service module preloading method provided in an embodiment of the present application;

FIG. 4 is a flow chart of an embodiment of a method for skipping a service module according to an embodiment of the present application;

FIG. 5 is a schematic structural diagram of one embodiment of a service module preloading device provided in an embodiment of the present application;

fig. 6 is a schematic structural diagram of an embodiment of a service module jumping device according to an embodiment of the present application;

FIG. 7 is a schematic diagram of an embodiment of a computer device provided in an embodiment of the application.

Detailed Description

The following description of the embodiments of the present application will be made clearly and completely with reference to the accompanying drawings, in which it is apparent that the embodiments described are only some embodiments of the present application, but not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the application without making any inventive effort, are intended to fall within the scope of the application.

In the description of the present application, it should be understood that the terms "center", "longitudinal", "lateral", "length", "width", "thickness", "upper", "lower", "front", "rear", "left", "right", "vertical", "horizontal", "top", "bottom", "inner", "outer", etc. indicate orientations or positional relationships based on the drawings are merely for convenience in describing the present application and simplifying the description, and do not indicate or imply that the apparatus or elements referred to must have a specific orientation, be configured and operated in a specific orientation, and thus should not be construed as limiting the present application. Furthermore, the terms "first," "second," and the like, are used for descriptive purposes only and are not to be construed as indicating or implying a relative importance or implicitly indicating the number of technical features indicated. Thus, a feature defining "a first" or "a second" may explicitly or implicitly include one or more of the described features. In the description of the present application, the meaning of "a plurality" is two or more, and the inclusion of "a number" is one or more, unless specifically defined otherwise.

In the present application, the term "exemplary" is used to mean "serving as an example, instance, or illustration. Any embodiment described as "exemplary" in this disclosure is not necessarily to be construed as preferred or advantageous over other embodiments. The following description is presented to enable any person skilled in the art to make and use the application. In the following description, details are set forth for purposes of explanation. It will be apparent to one of ordinary skill in the art that the present application may be practiced without these specific details. In other instances, well-known structures and processes have not been described in detail so as not to obscure the description of the application with unnecessary detail. Thus, the present application is not intended to be limited to the embodiments shown, but is to be accorded the widest scope consistent with the principles and features disclosed herein.

It should be noted that, because the method of the embodiment of the present application is executed in the computer device, the processing objects of each computer device exist in the form of data or information, for example, time, which is essentially time information, it can be understood that in the subsequent embodiment, if the size, the number, the position, etc. are all corresponding data, so that the computer device can process the data, which is not described herein in detail.

The embodiment of the application provides a service module preloading method, a service module skipping device and a storage medium, which are respectively described in detail below.

Referring to fig. 1, fig. 1 is a schematic view of a service module preloading system according to an embodiment of the present application, where the service module preloading system may include a computer device 100, and a service module preloading device, such as the computer device in fig. 1, is integrated in the computer device 100.

In the embodiment of the present application, the computer device 100 is mainly used for obtaining a start request of a target application; determining a plurality of service modules which need to be preloaded according to the starting request; loading a preloading file of each service module in the plurality of service modules, and generating a native interface of each service module according to the preloading file and the preloading information of each service module, which is predetermined; the native interfaces of the service modules are cached in the cache pool, and when the computer equipment 100 enters the service module page, the native interfaces of the service modules can be directly obtained from the cache pool to display the page, so that the problem of white screen caused by waiting time of loading and rendering is avoided.

In the embodiment of the present application, the computer device 100 may be an independent server, or may be a server network or a server cluster formed by servers, for example, the computer device 100 described in the embodiment of the present application includes, but is not limited to, a computer, a network host, a single network server, a plurality of network server sets, or a cloud server formed by a plurality of servers. Wherein the Cloud server is composed of a large number of computers or web servers based on Cloud Computing (Cloud Computing).

It is to be understood that the computer device 100 used in embodiments of the present application may be a device that includes both receive and transmit hardware, i.e., a device having receive and transmit hardware capable of performing bi-directional communications over a bi-directional communication link. Such a device may include: a cellular or other communication device having a single-line display or a multi-line display or a cellular or other communication device without a multi-line display. The computer device 100 may be a desktop terminal or a mobile terminal, and the computer device 100 may be one of a mobile phone, a tablet computer, a notebook computer, and the like.

It will be appreciated by those skilled in the art that the application environment shown in fig. 1 is merely an application scenario of the present application, and is not limited to the application scenario of the present application, and that other application environments may include more or fewer computer devices than those shown in fig. 1, for example, only 1 computer device is shown in fig. 1, and that the service module preloading system may further include one or more other services, which are not limited herein.

In addition, as shown in fig. 1, the service module preloading system may further include a memory 200 for storing data, such as service module names of a plurality of service modules, for example, service module names of a purchase order module, a purchase cart module, a search module, and an order module in a certain purchase APP, such as a preloading file of a service module, specifically, a preloading file of a purchase cart module, a preloading file of a search module, and the like.

It should be noted that, the schematic view of the scenario of the service module preloading system shown in fig. 1 is only an example, and the service module preloading system and the scenario described in the embodiments of the present application are for more clearly describing the technical solutions of the embodiments of the present application, and do not constitute a limitation on the technical solutions provided by the embodiments of the present application, and as one of ordinary skill in the art can know, along with the evolution of the service module preloading system and the appearance of a new service scenario, the technical solutions provided by the embodiments of the present application are equally applicable to similar technical problems.

Firstly, in the embodiment of the present application, a service module preloading method is provided, an execution body of the service module preloading method is a service module preloading device, the service module preloading device is applied to a computer device, and the service module preloading method includes: acquiring a starting request of a target application; determining a plurality of service modules which need to be preloaded according to the starting request; loading a preloading file of each service module in the plurality of service modules, and generating a native interface of each service module according to the preloading file and the preloading information of each service module, which is predetermined; and caching the original interfaces of the service modules into a cache pool to realize the preloading of the service modules, wherein the cache pool is a preset cache resource pool for storing interface resources.

As shown in fig. 2, which is a schematic flow chart of an embodiment of a service module preloading method in an embodiment of the present application, the service module preloading method may include the following steps 301 to 304, which are specifically as follows:

301. and acquiring a starting request of the target application.

The target applications are Applications (APP) currently launched by the computer device, which may be generally classified on an object-oriented basis into personal user applications (e.g., personal micro-letter) and enterprise-level applications (e.g., enterprise micro-letter), which may include iOS (e.g., synchronization push, etc.), android (e.g., airDroid, hundred degree Application, etc.), and xap and APP x of windows phone on a mobile-side system split. The starting request is a starting instruction of a target application sent by a user to the computer equipment, and the starting request comprises but is not limited to a touch instruction, a mouse instruction, a remote control instruction, a voice instruction and the like, for example, when the user wants to start a shopping APP, the user directly clicks an icon of the shopping APP on a touch screen, or the user clicks the icon of the shopping APP on the touch screen through a mouse, or the user sends a voice instruction of opening the shopping APP. After a user sends a starting request of a target application to computer equipment, the computer acquires the starting request of the target application, and preloads a service module of the target application according to the starting request so as to avoid the problem of a white screen caused by loading and rendering of the service module of the target application into a page.

302. And determining a plurality of service modules which need to be preloaded according to the starting request.

The service modules are currently started service modules of the target application, and the service modules can be all service modules of the target application or part of service modules of the target application, for example, the APP of a certain shopping class is provided with a service module such as an order placing module, a shopping cart module, a searching module, an order placing module and the like. Considering that after a user starts a target application, there is a need for a service module entering the target application, after the embodiment obtains a starting request of the target application, a plurality of service modules, which need to be preloaded, in the target application are determined according to the starting request, so that the plurality of service modules are preloaded in a subsequent step.

In a specific embodiment, as shown in fig. 3, in step 302, determining, according to the start request, a number of service modules that need to be preloaded may include the following steps 401 to 402, which are specifically as follows:

401. determining a module name array corresponding to the target application according to the starting request, wherein the module name array is an array formed by service module names of a plurality of service modules which need to be preloaded in the target application;

402. And determining a plurality of business modules which need to be preloaded according to the module name array.

The module name array is an array formed by service module names of service modules needing to be preloaded in the target application, for example, when the service modules needing to be preloaded in the target application comprise an order placing module, a shopping cart module, a search module and an order module, the module name array corresponding to the target application is a character string array formed by service module names of the order placing module, the shopping cart module, the search module and the order module.

The preloading of the service modules is completed by a main thread of the target application, and when the main thread is started by the target application, the operating system of the computer equipment creates a thread corresponding to the target application. After receiving a starting request of a target application, the computer equipment creates a thread corresponding to the target application, namely a main thread of the target application, then transmits service module names of service modules needing to be preloaded in the target application to the main thread of the target application in an array form, and determines a plurality of service modules needing to be preloaded according to the module name array through the main thread of the target application so as to realize the preloading of the plurality of service modules in the subsequent steps.

In a specific embodiment, the determining, in step 402, a number of service modules that need to be preloaded according to the module name array may include the following steps 501 to 502 include:

501. acquiring preset corresponding relations between names of all service modules and the service modules;

502. and determining a plurality of business modules which need to be preloaded according to the module name array and the corresponding relation.

Because different APP is configured with different service modules, in order to preload the service modules for the different APP, in this embodiment, service module names for uniquely identifying each service module are preset, and a correspondence between the service module names and the service modules is set according to the service modules and the corresponding service module names thereof, for example, the service module name of the ordering module is an ordering, the service module name of the shopping cart module is a shopping cart, and the service module name of the searching module is a searching.

After the main thread of the target application obtains the module name array, the corresponding relation between each preset service module name and the service module is further obtained, each service module name in the module name array is compared with the obtained corresponding relation, and a plurality of service modules are determined according to the comparison result. For example, the module name array includes an order, a shopping cart and a search, and according to the module name array, it may be determined that the plurality of service modules include an order module, a shopping cart module and a search module.

In a specific embodiment, the determining, in step 302, a number of service modules that need to be preloaded according to the start request may include the following steps 403 to 404, which are specifically as follows:

403. judging whether a main thread corresponding to a target application is idle or not according to the starting request;

404. if the main line Cheng Kongxian, a number of traffic modules that need to be preloaded are determined.

In order to avoid the occupation of the preloading of the service module and the blockage of the UI rendering time of the interface, the preloading process of the service module is executed when the main thread of the target application is idle, that is, after the computer equipment acquires the starting request of the target application, whether the main thread of the target application is idle or not is judged according to the starting request, and when the main thread of the target application is idle, a plurality of service modules which need to be preloaded are determined; otherwise, continuing to monitor whether the main thread of the target application is idle.

The computer equipment comprises a thread monitoring module, and when judging whether the main thread of the target application is idle, the method specifically comprises the following steps: the method comprises the steps of monitoring the running cycle (Runloop) state of a main thread through a thread monitoring module, wherein the running cycle (Runloop) is a part of a thread-related basic framework and is used for scheduling work and processing input events, and the purpose of using the Runloop is to enable the thread to be busy with work when the thread is in work and to be in a dormant state when the thread is not in work. Run-cycle (Runloop) states of the main thread include an enter run-cycle state (runloopoentry), a process timing call-back state (runloopof-times), a process input event state (runloopof-sources), a pre-sleep call state (runloopof-ready), a wake-after-wake call state (runloopof-ready), and an exit run-cycle state (RunLoopExit). When the thread monitoring module monitors that the running cycle (Runloop) state of the main thread enters Runloop before sleep calling state, the main thread Cheng Kongxian of the target application is judged.

In a specific embodiment, the determining, in step 302, a number of service modules that need to be preloaded according to the start request may include the following step 405, specifically as follows:

405. and loading and rendering a homepage service module of the target application according to the starting request.

Applications typically consist of a home business module and some other business module, which is typically entered first when the application is started. In order not to influence the page display of the homepage service module, when the computer equipment receives the starting request of the target application, the homepage service module of the target application is loaded and rendered according to the starting request, and after the homepage service module of the target application is loaded and rendered, a plurality of other service modules of the target application are preloaded. For example, when the target application is a shopping APP, after the shopping APP is started, the homepage service module is loaded and rendered, and after the homepage service module is loaded and rendered, the pre-loading of the order placing module, the shopping cart module, the searching module, the order placing module and the like is performed.

303. Loading a preloading file of each service module in the plurality of service modules, and generating a native interface of each service module according to the preloading file and the preloading information of the service module.

Each service module corresponds to a preloaded file, the preloaded files are generated by script packages provided by a development framework of a target application, for example, common APP development frameworks comprise Native APP, web APP, hybrid APP, weex and real Native, and when the target application is developed by the real Native development framework, the preloaded files are Bundle files, which are generated by node. Js script packages provided by real Native. The pre-load information is some initial information that the service module pre-loads, such as device information, operating system version number, etc., which is determined by the system hardware parameters of the target application running. The Native interface is a Native interface when each service module performs page display, and is generated by a preloaded file of each service module and preloaded information of each service module, for example, when a target application is developed through a real Native development framework, the Native interface of each service module is a real rootview. After a plurality of service modules needing to be preloaded are determined, loading the preloaded files of each service module through multithreading asynchronous concurrency, and caching the preloaded files of each service module into a memory, wherein each time the preloaded files of one service module are loaded, the thread corresponding to the preloaded files is switched from an asynchronous sub-thread to a main thread. After loading the pre-loaded files of each service module, pre-determined pre-loaded information of each service module is obtained, and a primary interface of each service module is generated according to the pre-loaded files of each service module and the pre-loaded information of each service module.

The pre-loading information can be generated after a plurality of service modules needing to be pre-loaded are determined, and can also be generated before the target application is started, when the pre-loading information is generated after a plurality of service modules needing to be pre-loaded are determined, after a plurality of service modules needing to be pre-loaded are determined according to a starting request, the pre-loading information of each service module is generated according to the system hardware parameters of the operation of the target application. When the pre-loading information is generated before the target application is started, a plurality of service modules which need to be pre-loaded by the target application are needed to be determined first, and then the pre-loading information of each service module is generated according to the system hardware parameters.

In a specific embodiment, when the pre-loading information is generated before the target application is started, before the start request of the target application is obtained in step 301, the service module pre-loading method may include the following steps 406 to 407, which are specifically as follows:

406. acquiring a service module file set of the target application, wherein the service module file set is a file set formed by resource files of service modules in the target application;

407. and generating the preloading information of each service module according to the service module file set.

The service module file set is a folder set generated after the target application is developed by the development framework of the target application, for example, when the target application is developed by the real Native development framework, the service module file set is a folder set generated by the real Native, and the service module file set is a file set formed by resource files of the service modules in the target application, and according to the resource files in the service module file set, the service modules required to be preloaded by the target application can be determined. For example, when the service module file set traverses to the resource file of the a service module, it is determined that the a service module needs to be preloaded.

In order to accelerate the preloading of the service modules, in this embodiment, the preloading information of each service module is generated before the start request of the target application is acquired. Specifically, firstly, a service module file set of the target application is obtained, then a plurality of resource files in the service module file set are traversed, after the service module, which is needed to be preloaded by the target application, is determined according to the traversing results of the plurality of resource files in the service module file, the preloading information of each service module is generated according to the system hardware parameters operated by the target application.

In a specific embodiment, with continued reference to fig. 3, the generating, in step 303, the native interface of each service module according to the pre-loaded file and the pre-determined pre-loaded information of each service module may include the following steps 601 to 602, which are specifically as follows:

601. obtaining JS codes in the preloaded file;

602. and generating a primary interface of each business module according to the JS codes and the pre-determined pre-loading information of each business module.

The preloaded files comprise JS codes for page display and interaction, when the original interfaces of the service modules are respectively generated according to the preloaded files of the service modules, the JS codes for page display and interaction are firstly obtained from the preloaded files of the service modules, and then the original interfaces of the service modules are generated according to the JS codes of the service modules and the preloaded information of the service modules, so that page display or skip among the service modules can be carried out according to the original interfaces of the service modules in the follow-up steps.

304. And caching the original interfaces of the service modules into a cache pool to realize the preloading of the service modules, wherein the cache pool is a preset cache resource pool for storing interface resources.

In order to realize the preloading of each service module, in this embodiment, a buffer resource pool for storing page resources of the service module is preset, after the native interfaces of each service module are generated, the native interfaces of each service module are buffered in the buffer pool, and when the page of the service module needs to be accessed, the preloading file buffered in the memory and the native interfaces buffered in the buffer pool can be directly pulled for interface display, so that the problem of white screen caused by the waiting time of loading and rendering when the page of the service module is accessed is avoided. For example, when a shopping cart module needs to be accessed, a preloaded file of the shopping cart module cached in the memory and a native interface of the shopping cart module cached in the cache pool can be taken by a main line Cheng La of the shopping APP to display a page of the shopping cart module.

As shown in fig. 4, which is a flow chart of an embodiment of a service module skipping method according to the present application, the service module skipping method may include the following steps 305 to 306, which are specifically as follows:

305. when a jump instruction for jumping to a target service module is received, acquiring a primary interface of the target service module from a cache pool;

306. and displaying the page of the target service module according to the original interface of the target service module and the preloading file of the target service module.

The jump instruction is a service module jump instruction sent by a user to the computer device, and the starting instruction includes, but is not limited to, a touch instruction, a mouse instruction, a remote control instruction, a voice instruction and the like, for example, when the user wants to jump from a homepage service module to an order-placing module for a shopping APP, the user can directly click an icon of the order-placing module on a touch screen, or the user clicks the icon of the order-placing module on the touch screen through a mouse, or the user sends a voice instruction of opening the order-placing module. The target service module is a service module to be displayed after the jump, for example, when the jump instruction is from the homepage service module to the order placing module, the target service module is the order placing module.

When the computer equipment receives a jump instruction from a user to a target service module, the traditional method needs to load and render the target service module, so that the jump between the service modules is caused to occur for a period of white screen time. For example, taking the iOS system as an example, when a shopping APP needs to jump from a homepage service module to an order-placing module, the iOS middleware can be invoked to jump between modules, and a pre-loaded file of the order-placing module cached in a memory and a native interface of the order-placing module cached in a cache pool are pulled through the iOS, and page display is performed on the order-placing module according to the native interface of the order-placing module and the pre-loaded file of the order-placing module.

In a specific embodiment, before the step 305 of obtaining the native interface of the target service module from the cache pool, the service module skipping method may include the following steps 408 to 409, which are specifically as follows:

408. obtaining a cache mark in the cache pool, and determining whether a native interface of the target service module exists in the cache pool according to the cache mark;

409. and when the original interface of the target service module does not exist in the cache pool, generating the original interface of the target service module according to the pre-loading file of the target service module and pre-determined pre-loading information of the target service module.

The cache mark is an identifier for recording the service modules which are already cached and stored in the cache pool, and considering that in the process of preloading a plurality of service modules, the situation that the original interfaces of the service modules are not cached in the cache pool may exist, and for each service module, after the original interfaces of the service modules are cached in the cache pool, the cache mark corresponding to the service module is generated in the cache pool. For example, after the original interfaces of the order placing module, the shopping cart module, the searching module and the order placing module are cached in the cache pool, cache marks corresponding to the order placing module, the shopping cart module, the searching module and the order placing module are respectively generated in the cache pool.

After receiving a jump instruction sent by a user and jumping to a target service module, the computer equipment can firstly acquire a cache mark of a cache pool, determine whether a primary interface of the target service module exists in the cache pool according to the cache mark, and when judging that the primary interface of the target service module does not exist in the cache pool according to the cache mark, generate the primary interface of the target service module according to a pre-loaded file of the target service module and pre-determined pre-loaded information of the target service module so as to display pages of the target service module; when the existence of the original interface of the target service module in the cache pool is judged according to the cache mark, the original interface of the target service module is directly obtained from the cache pool to display the interface of the target service module. When the original interface of the target service module does not exist in the cache pool, the page display can be performed on the target service module only by generating the original interface of the target service module, but because the original interface can be generated by directly acquiring the pre-loading information from the memory, the page display is performed, compared with the mode that when the existing page display is performed, the data is required to be loaded from the hard disk to the memory, and then the page rendering is performed, the page skip speed is faster.

Considering that the number of the primary interfaces of the service modules cached in the cache pool is too large, the memory is occupied, the speed of the service module when the page is displayed is reduced, in the embodiment, the used primary interfaces in the cache pool can be cleaned according to the preset rule, and the cache marks of the service modules corresponding to the cleaned primary interfaces are removed from the cache pool. The preset rules include, but are not limited to, APP usage time, APP usage frequency, service module usage time, service module usage frequency, and the like. For example, after the APP is closed, cleaning a native interface of a service module corresponding to the APP in the cache pool; when the APP is not used for more than a preset time, if the APP is not started for more than three months, the original interface of the service module corresponding to the APP in the cache pool is cleaned.

In order to better implement the service module preloading method in the embodiment of the present application, on the basis of the service module preloading method, the embodiment of the present application further provides a service module preloading device, as shown in fig. 5, where the service module preloading device 700 includes:

a request acquisition unit 701, configured to acquire a start request of a target application;

a module determining unit 702, configured to determine, according to the start request, a plurality of service modules that need to be preloaded;

An interface generating unit 703, configured to load a preloading file of each service module in the plurality of service modules, and generate a native interface of each service module according to the preloading file and predetermined preloading information of each service module;

and the preloading unit 704 is configured to cache the native interfaces of the service modules to a cache pool, so as to implement preloading of the service modules, where the cache pool is a preset cache resource pool for storing interface resources.

In the embodiment of the application, a plurality of service modules which need to be preloaded are determined according to the starting request, the original interfaces of the service modules are generated according to the preloading files of the service modules and the preloading information of the service modules in the service modules, the original interfaces of the service modules are cached in the cache pool, and when pages of the service modules are entered, the original interfaces of the service modules can be directly obtained from the cache pool for page display, so that the problem of white screen caused by waiting time of loading and rendering is avoided, and smooth and white-screen-free service module skip is realized.

In some embodiments of the present application, the module determining unit 702 is specifically configured to:

In some embodiments of the present application, the module determining unit 702 is specifically further configured to:

In some embodiments of the present application, the service module preloading device 700 further includes:

In some embodiments of the present application, the interface generating unit 703 is specifically configured to:

Obtaining JS codes in the preloaded file;

and the file generation unit is used for generating the preloading information of each service module according to the service module file set.

In some embodiments of the present application, the interface generating unit 702 is specifically further configured to:

In an embodiment of the present application, as shown in fig. 6, a service module jumping device is further provided, where the service module jumping device 800 includes:

a module jump unit 801, configured to obtain, when a jump instruction for jumping to a target service module is received, a native interface of the target service module from a cache pool;

and the page display unit 802 is configured to display a page of the target service module according to the native interface of the target service module and the preloaded file of the target service module.

In some embodiments of the present application, the service module jumping apparatus 800 further includes:

The embodiment of the application also provides a computer device, which integrates any of the service module preloading devices provided by the embodiment of the application, and the computer device comprises:

one or more processors;

a memory; and

one or more applications, wherein the one or more applications are stored in the memory and configured to perform the steps of the business module preloading method described in any of the business module preloading method embodiments described above by the processor.

The embodiment of the application also provides computer equipment which integrates any of the service module preloading devices provided by the embodiment of the application. As shown in fig. 7, a schematic structural diagram of a computer device according to an embodiment of the present application is shown, specifically:

the computer device may include one or more processors 901 of a processing core, one or more memories 902 of a computer readable storage medium, a power supply 903, and an input unit 904, among other components. Those skilled in the art will appreciate that the computer device structure shown in FIG. 7 is not limiting of the computer device and may include more or fewer components than shown, or may be combined with certain components, or a different arrangement of components. Wherein:

processor 901 is the control center of the computer device, connecting the various parts of the entire computer device using various interfaces and lines, performing various functions of the computer device and processing data by running or executing software programs and/or modules stored in memory 902, and invoking data stored in memory 902, thereby performing overall monitoring of the computer device. Optionally, processor 901 may include one or more processing cores; preferably, the processor 901 may integrate an application processor and a modem processor, wherein the application processor primarily handles operating systems, user interfaces, applications, etc., and the modem processor primarily handles wireless communications. It will be appreciated that the modem processor described above may not be integrated into the processor 901.

The memory 902 may be used to store software programs and modules, and the processor 901 performs various functional applications and data processing by executing the software programs and modules stored in the memory 902. The memory 902 may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program (such as a sound playing function, an image playing function, etc.) required for at least one function, and the like; the storage data area may store data created according to the use of the computer device, etc. In addition, the memory 902 may include high-speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other volatile solid-state storage device. Accordingly, the memory 902 may also include a memory controller to provide access to the memory 902 by the processor 901.

The computer device further comprises a power supply 903 for powering the various components, preferably the power supply 903 is logically connected to the processor 901 via a power management system, whereby the functions of managing charging, discharging, and power consumption are performed by the power management system. The power supply 903 may also include one or more of any components, such as a direct current or alternating current power supply, a recharging system, a power failure detection circuit, a power converter or inverter, a power status indicator, and the like.

The computer device may also include an input unit 904, which input unit 904 may be used to receive input numeric or character information, and to generate keyboard, mouse, joystick, optical or trackball signal inputs related to user settings and function control.

Although not shown, the computer device may further include a display unit or the like, which is not described herein. In particular, in this embodiment, the processor 901 in the computer device loads executable files corresponding to the processes of one or more application programs into the memory 902 according to the following instructions, and the processor 901 executes the application programs stored in the memory 902, so as to implement various functions as follows:

acquiring a starting request of a target application;

Those of ordinary skill in the art will appreciate that all or a portion of the steps of the various methods of the above embodiments may be performed by instructions, or by instructions controlling associated hardware, which may be stored in a computer-readable storage medium and loaded and executed by a processor.

To this end, an embodiment of the present application provides a computer-readable storage medium, which may include: read Only Memory (ROM), random access Memory (RAM, random Access Memory), magnetic or optical disk, and the like. On which a computer program is stored, which is loaded by a processor to perform the steps of any of the service module preloading methods provided by the embodiments of the present application. For example, the loading of the computer program by the processor may perform the steps of:

acquiring a starting request of a target application;

In the foregoing embodiments, the descriptions of the embodiments are focused on, and the portions of one embodiment that are not described in detail in the foregoing embodiments may be referred to in the foregoing detailed description of other embodiments, which are not described herein again.

In the implementation, each unit or structure may be implemented as an independent entity, or may be implemented as the same entity or several entities in any combination, and the implementation of each unit or structure may be referred to the foregoing method embodiments and will not be repeated herein.

The specific implementation of each operation above may be referred to the previous embodiments, and will not be described herein.

The foregoing describes in detail a service module preloading method, a jump method, a device and a storage medium provided by the embodiments of the present application, and specific examples are applied to illustrate the principles and implementations of the present application, where the foregoing description of the embodiments is only for helping to understand the method and core ideas of the present application; meanwhile, as those skilled in the art will have variations in the specific embodiments and application scope in light of the ideas of the present application, the present description should not be construed as limiting the present application.

Claims

1. A service module preloading method, characterized in that the service module preloading method comprises:

acquiring a starting request of a target application;

2. The service module preloading method of claim 1, wherein said determining, according to the start request, a number of service modules that need to be preloaded includes:

3. The service module preloading method of claim 2, wherein said determining a number of service modules to be preloaded according to said array of module names includes:

4. The service module preloading method of claim 1, wherein the preloading file includes JS code for page presentation and interaction, and the generating a native interface of each service module according to the preloading file and the predetermined preloading information of each service module includes:

obtaining JS codes in the preloaded file;

5. The method for preloading a service module according to any of claims 1-4, wherein prior to the obtaining a start request of a target application, the method further comprises:

6. The service module preloading method according to any of claims 1-4, wherein said determining, according to the start-up request, a number of service modules that need to be preloaded further comprises:

7. The service module preloading method of claim 1, wherein said determining a number of service modules that need to be preloaded according to said start-up request further comprises:

8. A service module skipping method, applied to a service module preloaded by a service module preloading method as claimed in any of claims 1 to 7, comprising:

9. The method for skipping a service module according to claim 8, wherein before said obtaining the native interface of the target service module from the cache pool, the method further comprises:

10. A service module preloading device, characterized in that the service module preloading device comprises:

the request acquisition unit is used for acquiring a starting request of the target application;

11. A computer readable storage medium, having stored thereon a computer program, the computer program being loaded by a processor to perform the steps of the traffic module preloading method of any of claims 1-7, or to perform the traffic module skipping method of claim 8 or 9.