WO2023024436A1

WO2023024436A1 - Page loading method, assembly, system, apparatus, and computer-readable storage medium

Info

Publication number: WO2023024436A1
Application number: PCT/CN2022/074662
Authority: WO
Inventors: 肖彦均; 沈玺; 汤之雄; 解楠
Original assignee: 中国银联股份有限公司
Priority date: 2021-08-23
Filing date: 2022-01-28
Publication date: 2023-03-02
Also published as: CN113742623A

Abstract

A page loading method, an assembly, a system, an apparatus, and a computer-readable storage medium. The method comprises: a container module executing initialization in response to a trigger instruction; in response to a trigger instruction, a preloading module executing: obtaining a page source code; analyzing the page source code to generate a first static resource request and sending said request to a resource request module, and sending to the container module a page source code into which a preset code has been statically injected; the container module loading the successfully injected page source code, using interception technology to generate a second static resource request and sending said request to the resource request module; and in response to the first static resource request, the resource request module obtaining a corresponding static resource in advance, and, in response to the second static resource request, returning a target static resource to the container module. By using the aforementioned method, in one aspect, the timing of container initialization and static resource requests is optimized, and page opening speed is increased. In another aspect, the injection success rate is improved by means of adopting static injection technology.

Description

Page loading method, component, system, device and computer-readable storage medium

This application claims the priority of the Chinese patent application with application number 202110967875.9 and titled "Page loading method, component, system, device, and computer-readable storage medium" filed on August 23, 2021. The Chinese patent application The disclosure is incorporated herein by reference.

technical field

The invention belongs to the field of web pages, and in particular relates to a page loading method, component, system, device and computer-readable storage medium.

Background technique

This section is intended to provide a background or context for implementations of the invention that are recited in the claims. The descriptions herein are not admitted to be prior art by inclusion in this section.

With the launch of small program functions such as "Union QuickPass", more and more external access parties choose to access services through small programs, which puts higher demands on the convenience of accessing small programs and the speed of page opening. Require. At this stage, if the external access party wants to access the business, it needs to rely on the relevant static resources of small programs such as "Cloud QuickPass" in its own project to reduce the workload of the access party.

The opening of the applet page is generally divided into three steps: one is to initialize the applet container, the other is to parse the page, request static resources, and the third is to load and render the page. Generally speaking, these three steps are executed sequentially by the system webview according to serial logic, and the time required to open the page is the sum of the three steps. In this way, the user sees a long loading white screen. Moreover, existing applet containers generally use a dynamic injection scheme to inject the code of related static resources, that is, code injection is performed in the lifecycle function of the applet page loading, which easily leads to logic errors on the page and cannot guarantee the success of the injection. Rate.

Contents of the invention

Aiming at the problems existing in the above-mentioned prior art, a page loading method, component, system, device and computer-readable storage medium are proposed, and the above-mentioned problems can be solved by using the method, device and computer-readable storage medium.

The present invention provides the following solutions.

In the first aspect, there is provided a page loading method, which is characterized in that it is applied to an application client, and the application client includes a container module, a preload module and a resource request module, and the method includes: the container module executes initialization in response to a trigger instruction; preload The module executes in response to the trigger instruction: obtain the page source code; analyze the page source code to generate the first static resource request and send it to the resource request module, and send the page source code statically injected with the preset code to the container module; the container module loads the successfully injected page source code , using interception technology to generate a second static resource request and send it to the resource request module; and, the resource request module pre-obtains the corresponding static resource in response to the first static resource request, and returns the target static resource to the container module in response to the second static resource request resource.

In one embodiment, the container module is an applet container.

In one embodiment, the method further includes: in response to the application start instruction, the application client sends an update request to the server to update the preset resource package.

In one embodiment, the application client sends an update request to the server to update the preset resource package, and further includes: the application client sends an update request carrying the characteristic value of the local preset resource package to the server; the application client sends an update request to the server; Receive the difference package sent by the server, the difference package is generated according to the characteristic value of the local preset resource package, the latest resource package and its characteristic value; the application client combines the difference package and the local preset resource package to obtain Updated pre-built resource packs.

In one embodiment, the method further includes: the container module responds to the trigger instruction of opening the target applet page, acquires and initializes the uniform resource locator of the target applet page; in parallel, the preloading module responds to opening the target applet page The page trigger instruction obtains the page source code corresponding to the target applet page, and executes the first static resource request and static injection according to the page source code.

In one embodiment, the method further includes: the preloading module analyzes the page source code through a preset parsing framework to obtain the static resource dependencies therein; and sends the first static resource request to the resource request module according to the static resource dependencies.

In one embodiment, the method further includes: the preloading module writes the preset code that needs to be injected into the page source code corresponding to the target applet page through the preset parsing framework; the preset code includes: static resources required by the page source code Quote code.

In one embodiment, the resource requesting module pre-obtains the corresponding static resource in response to the first static resource request, and further includes: when the resource requesting module receives the first static resource request, presetting the resource according to the first static resource request The first resource matching is performed in the package; if the first resource matching is unsuccessful, the second resource matching is performed in the local network cache; if the second resource matching is unsuccessful, a network request is sent to update the local network cache.

In one embodiment, returning the target static resource to the container module in response to the second static resource request includes: when the resource request module receives the second static resource request, performing The third resource is matched; if the third resource is successfully matched, the matched static resource is returned to the container module; if the third resource is not successfully matched, the fourth resource is matched in the local network cache; if the fourth resource is successfully matched, Then return the matched static resource to the container module; if the fourth resource is not matched successfully, send a network request to obtain the target static resource.

In an implementation manner, the network request includes: a network request for service static resources and/or external static resources configured by the resource management platform.

In a second aspect, a page loading component is provided, which is applied to an application client, including: a container module, configured to execute initialization in response to a trigger instruction; a preload module, configured to execute in response to the trigger instruction: obtain page source code ; Analyze the page source code to send the first static resource request to the resource request module, and send the page source code statically injected with the preset code to the container module; the container module is also used to load the successfully injected page source code, intercept the static resource request therein and Sending a second static resource request to the resource request module; and a resource request module, configured to pre-acquire corresponding static resources in response to the first static resource request, and return a target static resource to the container module in response to the second static resource request.

In one embodiment, the container module is an applet container.

In one embodiment, the loading component is further configured to: send an update request to the server in response to the application start instruction, so as to update the preset resource package.

In one embodiment, the loading component is also used to: send an update request carrying the characteristic value of the local preset resource package to the server; , the current latest resource package and its characteristic values; combine the difference package and the local preset resource package to obtain an updated preset resource package.

In one embodiment, it is characterized in that the container module is configured to obtain and initialize the uniform resource locator of the target applet page in response to a trigger instruction for opening the target applet page; in parallel, the preload module is configured to In response to the trigger instruction for opening the target applet page, the page source code corresponding to the target applet page is obtained, and the first static resource request and static injection are performed according to the page source code.

In one embodiment, the preloading module is configured to: analyze the page source code through a preset parsing framework to obtain static resource dependencies therein; and send a first static resource request to the resource request module according to the static resource dependencies.

In one embodiment, the preloading module is used to: write the preset code that needs to be injected into the page source code corresponding to the target applet page through the preset parsing framework; the preset code includes: static resources required by the page source code Quote code.

In one embodiment, the resource request module is configured to: when receiving the first static resource request, perform the first resource matching in the preset resource package according to the first static resource request; if the first resource matching fails, The second resource is matched in the local network cache; if the second resource is not matched successfully, a network request is sent to update the local network cache.

In one embodiment, the resource request module is configured to: when receiving the second static resource request, perform third resource matching in the preset resource package according to the second static resource request; if the third resource matching is successful, then Return the matched static resource to the container module; if the third resource is not matched successfully, perform the fourth resource match in the local network cache; if the fourth resource is successfully matched, return the matched static resource to the container module; 4. If resource matching fails, a network request is sent to obtain the target static resource.

In the third aspect, a page loading system is provided, including: an application client, which includes the page loading component as in the second aspect; an application server, which includes a resource management platform, and is used to issue updated preset resources to the application client Package and/or used to provide business static resources to application clients.

In a fourth aspect, there is provided a page loading device, comprising: at least one processor; and a memory connected in communication with the at least one processor; wherein, the memory stores instructions executable by at least one processor, and the instructions are processed by at least one processor executed by a processor, so that at least one processor can execute: the method of the first aspect.

In a fifth aspect, a computer-readable storage medium is provided. The computer-readable storage medium stores a program, and when the program is executed by a multi-core processor, the multi-core processor executes the method in the first aspect.

The above-mentioned at least one technical solution adopted in the embodiment of the present application can achieve the following beneficial effects: In this embodiment, on the one hand, the timing of container initialization and static resource requests is optimized, and there is no need to wait until the container initialization is completed before starting to execute parsing pages and requesting static resources etc., to achieve the purpose of optimizing the loading timing and speeding up the page opening speed. On the other hand, this solution adopts static injection technology, and the injection is completed through static injection before loading the page, and the timing of injection is advanced to ensure successful injection.

It should be understood that the above description is only an overview of the technical solution of the present invention, so as to understand the technical means of the present invention more clearly, so as to be implemented according to the contents of the description. In order to make the above and other objects, features and advantages of the present invention more comprehensible, specific embodiments of the present invention are illustrated below.

Description of drawings

The advantages and benefits described herein, as well as other advantages and benefits, will be apparent to those of ordinary skill in the art upon reading the following detailed description of the exemplary embodiments. The drawings are only for the purpose of illustrating exemplary embodiments and are not to be considered as limiting the invention. Also throughout the drawings, the same reference numerals are used to denote the same parts. In the attached picture:

FIG. 1 is a schematic structural diagram of a page loading component according to an embodiment of the present invention;

FIG. 2 is a schematic flowchart of a page loading method according to an embodiment of the present invention;

FIG. 3 is a schematic flowchart of a page loading method according to another embodiment of the present invention;

Fig. 4 is a schematic diagram of a page loading example according to an embodiment of the present invention;

FIG. 5 is a schematic structural diagram of a page loading system according to an embodiment of the present invention;

Fig. 6 is a schematic structural diagram of a page loading component according to an embodiment of the present invention.

In the drawings, the same or corresponding reference numerals denote the same or corresponding parts.

Detailed ways

Exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be limited by the embodiments set forth herein. Rather, these embodiments are provided for more thorough understanding of the present disclosure and to fully convey the scope of the present disclosure to those skilled in the art.

In the description of the embodiments of the present application, it should be understood that terms such as "comprising" or "having" are intended to indicate the existence of the features, numbers, steps, acts, components, parts or combinations thereof disclosed in the specification, and do not It is intended to exclude the possibility of the existence of one or more other features, figures, steps, acts, parts, parts or combinations thereof.

Unless otherwise specified, "/" means or, for example, A/B can mean A or B; "and/or" in this article is just an association relationship describing associated objects, indicating that there can be three relationships, For example, A and/or B may mean that A exists alone, A and B exist simultaneously, and B exists alone.

The terms "first", "second", etc. are used for descriptive purposes only, and should not be understood as indicating or implying relative importance or implicitly specifying the quantity of the indicated technical features. Thus, a feature defined as "first", "second", etc. may expressly or implicitly include one or more of that feature. In the description of the embodiments of the present application, unless otherwise specified, "plurality" means two or more.

All codes in this application are exemplary, and those skilled in the art will think of various modifications without departing from the idea of this application according to factors such as the programming language used, specific requirements, and personal habits.

In order to clearly illustrate the embodiments of the present application, some concepts that may appear in subsequent embodiments will be introduced first.

Static resources (StaticResources), which include js, css, img and other files generated by non-server dynamic running.

In addition, it should be noted that, in the case of no conflict, the embodiments of the present invention and the features in the embodiments can be combined with each other. The present invention will be described in detail below with reference to the accompanying drawings and examples.

As shown in Figure 1, the page loading method provided by this application is applied to an application client, such as a WeChat client, and the application client includes a page loading component composed of a container module 11, a preload module 12 and a resource request module 13 10.

Fig. 2 is a schematic flow diagram of a page loading method according to an embodiment of the present application. In this flow, from a device point of view, the executing subject may be one or more electronic devices; from a program point of view, the executing subject may correspondingly It is a program installed on these electronic devices. In this embodiment, the execution subject of the method may be the page loading component in the embodiment shown in FIG. 1 .

As shown in Figure 2, the method provided in this embodiment may include the following steps:

S21. The container module and the preloading module receive a trigger instruction.

Specifically, the container module may be an applet container. The triggering instruction may be a triggering instruction for opening a target applet page. For example, the trigger instruction is generated after the user clicks on the target applet icon. Furthermore, after receiving the trigger instruction, the container module and the preloading module execute their respective actions in parallel, so that the work originally performed in series can be changed into parallel execution.

S22. The container module executes initialization in response to the trigger instruction.

Specifically, the container module may, in response to a trigger instruction for opening the target applet page, acquire a uniform resource locator (URL) of the target applet page and perform initialization.

S23. The preloading module executes and acquires the source code of the page in response to the trigger instruction;

Specifically, the preloading module may respond to the trigger instruction of opening the target applet page, and obtain the page source code corresponding to the target applet page, such as HTML source code, so as to further execute the first static resource request and static injection according to the page source code.

S24. The preloading module analyzes the page source code to send the first static resource request to the resource request module;

Specifically, S24 is executed by the preloading module after obtaining the page source code in S23, and S25 is executed by the resource requesting module after S24 sends the first static resource request to the resource requesting module.

The first static resource request refers to a request sent by the preloading module to the resource requesting module for requesting static resources required by the page source code.

S25. The resource request module pre-obtains the corresponding static resource in response to the first static resource request;

Specifically, the resource request module can obtain the static resources required by the page source code based on a local preset resource package or a network request. In other words, the application can prepare the required static resources in advance before the page is loaded.

S26. The preloading module statically injects the preset code into the page source code and sends it to the container module;

Specifically, after the page source code is obtained in S23, the preloading module executes S26, and after S26 sends the successfully injected page source code to the container module, the container module executes S27.

The aforementioned preset code may be a reference code of a static resource, and after the page source code is statically injected into the preset code, the static resource required for reference can be directly loaded without repeatedly writing the code of these static resources. For example, the code to be injected can be directly written into the source code of the page through the Jsoup framework to complete the injection. It can be understood that the application platform usually provides a static resource package in advance, which includes the code of a large number of static resources available to developers. Developers do not need to repeatedly write the static resources in the source code of the page, only through static injection. Reference these static resources.

S27. The container module loads and injects the successfully injected page source code;

Specifically, there may be a time interval between S22 and S27. If the container module has been initialized before the static injection is completed, the container module will wait for the static injection to succeed before loading.

S28. The container module uses the interception technology to generate a second static resource request and sends it to the resource request module;

Specifically, during the page loading process, an interception technology is used to intercept static resource requests that need to be made during the loading process, and the request is handed over to the resource request module for processing. For example, the request can be intercepted through the shouldInterceptRequest method of the system webview.

S29. The resource request module acquires the target static resource in response to the second static resource request.

Specifically, in S25, the resource request module has obtained the static resources required by the page source code in advance based on the first static resource request. For example, you can cache static resources after making network requests. Therefore, during the page loading process, the time for the resource request module to obtain the target static resource is saved.

S30. The resource request module returns the target static resource to the container module.

On the one hand, this embodiment optimizes the timing of container initialization and static resource requests, and does not need to wait until the container initialization is completed before starting to execute parsing pages and requesting static resources. Instead, the timing of static resource requests is advanced, so that container initialization and static resource requests can be executed in parallel in two ways, so that the time for container initialization can be utilized; at the same time, through interception technology, resource package matching and request caching strategies are coordinated with resource presets , to achieve the purpose of optimizing the loading timing and speeding up the page opening speed.

Referring to Fig. 2, it is assumed that the first path: S21-S22; the second path: S21-S23-S26/(S24-S25). The second road can be further divided into the second road branch 1: S21-S23-S24-S25 and the second road branch 2: S21-S23-S26. The above-mentioned first path and the second path may be executed in parallel, and the two branches S24-S25 and S26 of the second path are also two branches executed in parallel. The aforementioned parallel execution does not require that each path or branch must start or end at the same time. For example, the container initialization of the first path may be completed relatively quickly. At this time, it is necessary to wait for the second branch 2 to return the successfully injected page source code before performing the subsequent page loading work.

Based on this, assuming that container initialization (that is, the first path: S21-S22) takes time T1, and requesting static resources (that is, the second path branch 1: S21-S23-S24-S25) takes time T2, static injection ( That is, the time spent on the second branch 2) is T3, and the time spent on loading the page is T4. Since the first path, the second path branch 1, and the second path branch 2 are executed in parallel, the total time spent is the sum of the maximum value among T1, T2, and T3 and T4. Compared with the traditional serial execution scheme, it takes less time.

On the other hand, this solution adopts static injection technology, and the injection is completed through static injection before loading the page, and the timing of injection is advanced to ensure successful injection.

Fig. 3 is a schematic flowchart of a page loading method shown in another exemplary embodiment of the present invention. This embodiment further describes the processes of S24, S25, S26, and S29 in detail on the basis of the embodiment shown in Fig. 2 .

In one embodiment, S24 may further include:

S241. The preloading module analyzes the source code of the page through a preset parsing framework to obtain static resource dependencies therein.

S242. The preloading module sends the first static resource request to the resource requesting module according to the static resource dependency.

The above static resource request is executed in parallel with container initialization. For example, after the resource preloading module obtains the HTML source code corresponding to the target applet page, it can parse the HTML page source code through the Jsoup framework, obtain the static resource dependencies, and request the corresponding resources through the resource request module.

In one embodiment, S26 may further include:

S261. The preloading module writes the preset code to be injected into the page source code corresponding to the target applet page through the preset parsing framework; the preset code includes: the reference code of the static resource required by the page source code.

S262. The preloading module sends the successfully injected page source code to the container module.

The above static injection is performed in parallel with container initialization. For example, after the preloading module obtains the HTML source code corresponding to the target applet page, it directly writes the code to be injected into the page source code through the Jsoup framework to complete the injection.

In one embodiment, S25 may further include:

S251. When the resource request module receives the first static resource request, perform first resource matching in the preset resource package according to the first static resource request. If the first resource is successfully matched, no processing is required.

S252. If the matching of the first resource is not successful, perform the matching of the second resource in the local network cache; if the matching of the second resource is successful, no processing is required.

S253. If the second resource is not successfully matched, send a network request;

S254. Receive the returned static resource and update the local network cache.

In short, the resource request module will first match the preset resource package. If it misses, it will continue to match in the local network cache. If it still misses, it will send a network request. After the request is successful, the local network cache will be updated.

The aforementioned preset resource package refers to a preset static resource package, which can be delivered by the application server to the application client. Further, in order to update the local preset resource package in the application client, the method may further include: in response to the application start instruction, the application client sends an update request to the server to update the preset resource package.

In one embodiment, the application client sends an update request to the server to update the preset resource package, which may also specifically include: the application client sends an update request carrying the characteristic value P1 of the local preset resource package to the server; The application client receives the difference package delivered by the server, which is generated based on the characteristic value P1 of the local preset resource package, the latest current resource package and its characteristic value P2; the application client combines the difference package and the local preset resource package Combine packages to get an updated pre-built resource package. In this way, an update with the same effect can be realized without sending the current latest resource package to the application client as a whole, saving resources.

Of course, the application server can also directly deliver the latest resource package to the application server to directly replace the client's local preset resource package, and the logic is simpler. This application does not specifically limit the update method and update timing of the preset resource package.

The foregoing network request may include: a network request for service static resources and/or external static resources configured by the resource management platform of the server.

In one embodiment, to further describe the static resource request in the page loading process, S29 may further include: when the resource request module receives the second static resource request, perform S291: Preset the resource package according to the second static resource request If the matching is successful, then directly execute S30: return the matched static resource to the container module; on the contrary, if the third resource is not successfully matched, then further execute S292: execute the fourth resource in the local network cache Matching; if the matching is successful, directly execute S30: return the matched static resource to the container module; on the contrary, if the matching of the fourth resource is still unsuccessful, further execute S293 and S294: send a network request to obtain the target static resource. And execute S303: return the target static resource to the container module.

In other words, when it is found that a static resource needs to be requested during the page loading process, the corresponding resource request will be intercepted and sent through the resource request module. Since the static resource request in the page has been sent in advance in the previous step, there are three situations at this time: 1. This resource belongs to the preset static resource, and the third resource matching can be directly matched and returned. 2. When the third resource is not matched, continue to match the fourth resource in the local network cache. If the first static resource request sent in advance in S25 is successful, it will be hit in the local network cache and returned directly . 3. When neither the third resource matching nor the fourth resource matching is a hit, it means that the first static resource request sent in advance in S25 has not been returned or the request failed. At this time, the network request can be made again to obtain the required network resources.

Fig. 4 shows a specific example of an embodiment of the present invention, which will be described exemplarily below in conjunction with Fig. 4 . The applet container is also the above-mentioned container module, wherein the applet container, the preload module and the resource request module are loading components in the application client. The resource management platform is located on the application server side and is mainly responsible for the configuration update of static resources on the business side. The update of business static resources is mainly divided into two parts. One is the update of the client’s preset resource package. The preset resource package mainly includes the general static resource files that the applet needs to use. The key is the URL of the static resource, and the value is the specific value of the static resource. document. The second is the update of business static resources, mainly including some business-related pictures and other resources.

Referring to FIG. 4 , it executes: (1) App startup: After the app starts, it will request the resource management platform to send the characteristic value p1 of the local preset package. (2) Update the local preset package: After receiving the request, the preset package update module of the server-side resource management platform will generate a corresponding difference package according to the characteristic value p1 sent by the client, the latest current resource package and its characteristic value p2, and download hair. After the application client receives the differential package sent by the server, it combines the packages, and the preset package update process ends. (3) Container initialization: the user clicks the entry of the target applet, the framework gets the URL of the applet page, and the applet container starts to initialize. (4) Request static resources in HTML: It is parallel to the initialization of the applet container. After the preloading module obtains the html source code corresponding to the target applet page, it analyzes the page code through the Jsoup framework, obtains the static resource dependencies, and uses the resource request module Request the corresponding resource; (5) Static resource matching: the resource request module will first match the preset package (that is, the preset resource package), if it is hit, it will not be processed; if it is not hit, it will continue to match in the cache, if it is hit, it will No processing; if there is a miss, a network request is sent, and the cache is updated after the request succeeds. The network requests here can be divided into two types, one is resource requests for business static resources configured on the resource management platform, and the other is external requests for external static resources. (6) Modify the HTML and statically inject the modified content: it is also parallel to the initialization of the applet. After the resource preloading module obtains the html source code corresponding to the target applet page, it directly writes the code to be injected into the page source code through the Jsoup framework to complete the injection , if the applet container has been initialized successfully before then, the applet container will wait for the static injection to succeed before continuing to execute. (7) The applet container loads the modified HTML: After the static injection is successful, the applet container obtains the modified HTML and enters the loading process. At this time, the container loads the HTML page after the successful injection. (8) Page loading: Enter the loading process. When it is found that a static resource needs to be requested during the page loading process, the corresponding resource request will be intercepted and sent to the resource request module for processing. Since the static resource request in the HTML page has been sent in advance in the previous step, at this time There are three situations: 1. This resource is a preset static resource, and the preset package is matched, and the hit is returned directly. 2. If the preset package misses, continue to match in the network cache. If the request sent in step (5) is successful, the hit will be returned directly. 3. If the first two cases are all missing, it means that the static resource request sent in advance in step (5) has not been returned or the request failed, and the external request can be sent directly.

In the description of this specification, descriptions referring to the terms "some possible implementations", "some embodiments", "examples", "specific examples", or "some examples" mean that the descriptions described in conjunction with the embodiments or examples A particular feature, structure, material, or characteristic is included in at least one embodiment or example of the invention. In this specification, the schematic representations of the above terms are not necessarily directed to the same embodiment or example. Furthermore, the described specific features, structures, materials or characteristics may be combined in any suitable manner in any one or more embodiments or examples. In addition, those skilled in the art can combine and combine different embodiments or examples and features of different embodiments or examples described in this specification without conflicting with each other.

In addition, the terms "first" and "second" are used for descriptive purposes only, and cannot be interpreted as indicating or implying relative importance or implicitly specifying the quantity of indicated technical features. Thus, the features defined as "first" and "second" may explicitly or implicitly include at least one of these features. In the description of the present invention, "plurality" means at least two, such as two, three, etc., unless otherwise specifically defined.

Any process or method descriptions in flowcharts or otherwise described herein may be understood to represent modules, segments or portions of code comprising one or more executable instructions for implementing specific logical functions or steps of the process , and the scope of preferred embodiments of the invention includes alternative implementations in which functions may be performed out of the order shown or discussed, including substantially concurrently or in reverse order depending on the functions involved, which shall It is understood by those skilled in the art to which the embodiments of the present invention pertain.

Regarding the method flow chart of the embodiment of the present application, certain operations are described as different steps performed in a certain order. Such flowcharts are illustrative and not restrictive. Certain steps described herein can be grouped together and performed in a single operation, can be divided into multiple sub-steps, and can be performed in an order different than that shown herein . It can be implemented in any way by any circuit structure and/or tangible mechanism (for example, by software running on a computer device, hardware (for example, logical functions implemented by a processor or a chip), etc., and/or any combination thereof). The individual steps shown in the flowchart.

Based on the same technical idea, an embodiment of the present invention also provides a page loading component, which is applied to an application client and used to execute the page loading method provided in any one of the above embodiments. FIG. 1 is a schematic structural diagram of a page loading component provided by an embodiment of the present invention.

As shown in Figure 1, the loading assembly 10 includes:

A container module 11, configured to perform initialization in response to a trigger instruction;

The preloading module 12 is used to execute in response to the trigger instruction: obtain the page source code; analyze the page source code to send the first static resource request to the resource request module, and send the page source code statically injected into the preset code to the container module;

The container module 11 is also used to load the successfully injected page source code, intercept the static resource request therein to send the second static resource request to the resource request module; and,

The resource request module 13 is configured to pre-acquire corresponding static resources in response to the first static resource request, and return the target static resource to the container module in response to the second static resource request.

In one embodiment, the container module is an applet container.

It should be noted that the page loading component in the embodiment of the present application can realize the various processes of the foregoing embodiments of the page loading method, and achieve the same effect and function, which will not be repeated here.

Fig. 5 is a page loading system according to an embodiment of the present application, including: an application client, which includes a page loading component as shown in Fig. 1; Configure resource packages and/or provide business static resources to application clients.

Fig. 6 is a page loading device according to an embodiment of the present application, which is used to execute the page loading method shown in the above embodiments, the device includes: at least one processor; and a memory connected to the at least one processor in communication; wherein The memory stores instructions executable by at least one processor, and the instructions are executed by at least one processor, so that the at least one processor can execute the methods of the above embodiments.

According to some embodiments of the present application, a non-volatile computer storage medium of a page loading method is provided, on which computer-executable instructions are stored, and the computer-executable instructions are configured to be executed when run by a processor: the above-mentioned embodiments method.

Each embodiment in the present application is described in a progressive manner, the same and similar parts of each embodiment can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the apparatus, equipment and computer-readable storage medium embodiments, since they are basically similar to the method embodiments, their descriptions are simplified, and for relevant parts, please refer to part of the description of the method embodiments.

The device, device, and computer-readable storage medium provided in the embodiments of the present application correspond to the method one-to-one. Therefore, the device, device, and computer-readable storage medium also have beneficial technical effects similar to their corresponding methods. The beneficial technical effect of the method has been described in detail, therefore, the beneficial technical effect of the device, equipment and computer-readable storage medium will not be repeated here.

Those skilled in the art should understand that the embodiments of the present invention may be provided as methods, systems or computer program products. Accordingly, the present invention can take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It should be understood that each procedure and/or block in the flowchart and/or block diagram, and a combination of procedures and/or blocks in the flowchart and/or block diagram can be realized by computer program instructions. These computer program instructions may be provided to a general purpose computer, special purpose computer, embedded processor, or processor of other programmable data processing equipment to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing equipment produce a An apparatus for realizing the functions specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing apparatus to operate in a specific manner, such that the instructions stored in the computer-readable memory produce an article of manufacture comprising instruction means, the instructions The device realizes the function specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions can also be loaded onto a computer or other programmable data processing device, causing a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process, thereby The instructions provide steps for implementing the functions specified in the flow chart or blocks of the flowchart and/or the block or blocks of the block diagrams.

In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

Memory may include non-permanent storage in computer-readable media, in the form of random access memory (RAM) and/or nonvolatile memory such as read-only memory (ROM) or flash RAM. Memory is an example of computer readable media.

Computer-readable media, including both permanent and non-permanent, removable and non-removable media, can be implemented by any method or technology for storage of information. Information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read only memory (ROM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Flash memory or other memory technology, Compact Disc Read-Only Memory (CD-ROM), Digital Versatile Disc (DVD) or other optical storage, Magnetic tape cartridge, tape magnetic disk storage or other magnetic storage device or any other non-transmission medium that can be used to store information that can be accessed by a computing device. In addition, while operations of the methods of the present invention are depicted in the figures in a particular order, there is no requirement or implication that these operations must be performed in that particular order, or that all illustrated operations must be performed, to achieve desirable results. Additionally or alternatively, certain steps may be omitted, multiple steps may be combined into one step for execution, and/or one step may be decomposed into multiple steps for execution.

Although the spirit and principles of the invention have been described with reference to a number of specific embodiments, it should be understood that the invention is not limited to the specific embodiments disclosed, nor does division of aspects imply that features in these aspects cannot be combined to achieve optimal performance. Benefit, this division is only for the convenience of expression. The present invention is intended to cover various modifications and equivalent arrangements included within the spirit and scope of the appended claims.

Claims

A page loading method, characterized in that it is applied to an application client, and the application client includes a container module, a preload module and a resource request module, and the method includes:

the container module performs initialization in response to a trigger instruction;

The preloading module executes in response to the trigger instruction: obtaining the page source code; analyzing the page source code to generate a first static resource request and sending it to the resource request module, and sending a static injection preset code to the container module The source code of the page;

The container module loads the successfully injected page source code, uses interception technology to generate a second static resource request and sends it to the resource request module; and,

The resource request module pre-obtains a corresponding static resource in response to the first static resource request, and returns a target static resource to the container module in response to the second static resource request.
The method according to claim 1, wherein the container module is an applet container.
The method according to claim 1 or 2, characterized in that the method further comprises:

In response to the application start instruction, the application client sends an update request to the server to update the preset resource package.
The method according to any one of claims 1-3, wherein the application client sends an update request to the server to update the preset resource package, further comprising:

The application client sends an update request carrying the characteristic value of the local preset resource package to the server;

The application client receives a differential packet sent by the server, and the differential packet is generated according to the characteristic value of the local preset resource packet, the latest current resource packet and its characteristic value;

The application client combines the difference package and the local preset resource package to obtain an updated preset resource package.
The method according to any one of claims 1-4, wherein the method further comprises:

The container module obtains and initializes the uniform resource locator of the target applet page in response to the trigger instruction of opening the target applet page; in parallel,

The preloading module obtains the page source code corresponding to the target applet page in response to the trigger instruction of opening the target applet page, and executes the first static resource request and the static injection according to the page source code.
The method according to any one of claims 1-5, wherein the method further comprises:

The preloading module analyzes the source code of the page through a preset parsing framework to obtain the static resource dependencies therein;

Sending the first static resource request to the resource request module according to the static resource dependency.
The method according to any one of claims 1-6, wherein the method further comprises:

The preloading module writes the preset code to be injected into the page source code corresponding to the target applet page through the preset parsing framework;

The preset code includes: the reference code of the static resource required by the page source code.
The method according to any one of claims 1-7, wherein the resource requesting module pre-acquires corresponding static resources in response to the first static resource request, further comprising:

When the resource request module receives the first static resource request, perform first resource matching in the preset resource package according to the first static resource request;

If the first resource matching is not successful, then perform second resource matching in the local network cache;

If the second resource is not matched successfully, a network request is sent to update the local network cache.
According to the method according to any one of claims 1-8, returning the target static resource to the container module in response to the second static resource request comprises:

When the resource request module receives the second static resource request, perform third resource matching in the preset resource package according to the second static resource request;

If the third resource is successfully matched, returning the matched static resource to the container module;

If the matching of the third resource is not successful, performing fourth resource matching in the local network cache;

If the matching of the fourth resource is successful, returning the matched static resource to the container module;

If the matching of the fourth resource is unsuccessful, a network request is sent to obtain the target static resource.
The method according to any one of claims 1-9, wherein the network request includes:

Network requests for business static resources and/or external static resources configured on the resource management platform.
A page loading component is characterized in that it is applied to an application client, including:

a container module for performing initialization in response to a trigger instruction;

A preloading module, configured to execute in response to the trigger instruction: obtain the page source code; analyze the page source code to send a first static resource request to the resource request module, and send a statically injected preset code request to the container module The source code of the page;

The container module is further configured to load the successfully injected page source code, intercept the static resource request therein to send a second static resource request to the resource request module; and,

The resource request module is configured to pre-acquire corresponding static resources in response to the first static resource request, and return a target static resource to the container module in response to the second static resource request.
The loading component according to claim 11, wherein the container module is an applet container.
The loading assembly according to claim 11 or 12, wherein the loading assembly is also used for:

In response to the application start instruction, an update request is sent to the server to update the preset resource package.
The loading assembly according to any one of claims 11-13, wherein the loading assembly is also used for:

Send an update request carrying the characteristic value of the local preset resource package to the server;

receiving a differential packet sent by the server, the differential packet is generated according to the characteristic value of the locally preset resource packet, the latest current resource packet and its characteristic value;

Combine the difference package and the local preset resource package to obtain an updated preset resource package.
The loading assembly according to any one of claims 11-14, characterized in that,

The container module is configured to, in response to a trigger instruction for opening the target applet page, obtain and initialize the uniform resource locator of the target applet page; in parallel,

The preloading module is configured to, in response to a trigger instruction for opening a target applet page, obtain the page source code corresponding to the target applet page, and execute the first static resource request and the static injection according to the page source code.
The loading assembly according to any one of claims 11-15, wherein the preloading module is used for:

Analyze the source code of the page through the preset analysis framework to obtain the static resource dependencies;

Sending the first static resource request to the resource request module according to the static resource dependency.
The loading assembly according to any one of claims 11-16, wherein the preloading module is used for:

Writing the preset code to be injected into the page source code corresponding to the target applet page through the preset parsing framework;

The preset code includes: the reference code of the static resource required by the page source code.
The loading component according to any one of claims 11-17, wherein the resource request module is configured to:

When receiving the first static resource request, perform first resource matching in the preset resource package according to the first static resource request;

If the first resource matching is not successful, then perform second resource matching in the local network cache;

If the second resource is not matched successfully, a network request is sent to update the local network cache.
The loading component according to any one of claims 11-18, the resource request module is configured to:

When receiving the second static resource request, perform third resource matching in the preset resource package according to the second static resource request;

If the third resource is successfully matched, returning the matched static resource to the container module;

If the matching of the third resource is not successful, performing fourth resource matching in the local network cache;

If the matching of the fourth resource is successful, returning the matched static resource to the container module;

If the matching of the fourth resource is unsuccessful, a network request is sent to obtain the target static resource.
The loading component according to any one of claims 11-19, wherein the network request includes:

Network requests for business static resources and/or external static resources configured on the resource management platform.
A page loading system, characterized in that it comprises:

An application client comprising the page loading component according to any one of claims 11-20;

The application server includes a resource management platform, configured to issue an update preset resource package to the application client and/or provide service static resources to the application client.
A page loading device, characterized in that it comprises:

At least one processor; and a memory connected in communication with the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can perform: The method of any one of claims 1-10.
A computer-readable storage medium, the computer-readable storage medium stores a program, and when the program is executed by a multi-core processor, the multi-core processor executes the method described in any one of claims 1-10 method.