CN111581563B

CN111581563B - Page response method and device, storage medium and electronic equipment

Info

Publication number: CN111581563B
Application number: CN202010366092.0A
Authority: CN
Inventors: 罗文�; 董阳; 屈苡智
Original assignee: Beijing ByteDance Network Technology Co Ltd
Current assignee: Beijing ByteDance Network Technology Co Ltd
Priority date: 2020-04-30
Filing date: 2020-04-30
Publication date: 2023-04-28
Anticipated expiration: 2040-04-30
Also published as: CN111581563A

Abstract

The disclosure relates to a page response method, a page response device, a storage medium and an electronic device, wherein the page response method comprises the following steps: determining a target page requested by the page request according to the received page request; determining target components contained in the target page according to the configuration information of the target page; acquiring a first file of a target component, wherein the first file is a resource file of the target component; loading a target component according to the first file and a second file imported in a global variable form, wherein the second file comprises a package file on which the target component depends; rendering the target page according to the target component to respond to the page request. Therefore, when the target page is rendered, all the components do not need to be loaded, and the on-demand loading of the components can be realized, so that the resources occupied by the loaded components can be reduced. Meanwhile, the package file on which the target component depends is imported in a global variable form, so that the expansion and dynamic loading of the component are facilitated, and the page response efficiency is improved.

Description

Page response method and device, storage medium and electronic equipment

Technical Field

The disclosure relates to the field of computer technology, and in particular, to a page response method, a page response device, a storage medium and electronic equipment.

Background

In the prior art, the front-end page development mode is based on writing front-end codes by an editor, compiling the front-end codes and then delivering the front-end codes to a CDN (Content Delivery Network ). When a user accesses a page, a page request may be initiated to access a resource located to the page via a URL (Uniform Resource Locator ), thereby performing a page response. In the above process, the resources required for loading the components when rendering the page are large, and if component code sharing is to be realized, the component code needs to be packed into npm packets, so that loading and sharing of the components are inconvenient through import (import) references.

Disclosure of Invention

This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the detailed description. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.

In a first aspect, the present disclosure provides a page response method, the method comprising: determining a target page requested by a page request according to the received page request; determining a target component contained in the target page according to the configuration information of the target page; acquiring a first file of the target component, wherein the first file is a resource file of the target component; loading the target component according to the first file and a second file imported in a global variable form, wherein the second file comprises a package file on which the target component depends; and rendering the target page according to the target component so as to respond to the page request.

In a second aspect, the present disclosure provides a page response apparatus, the apparatus comprising: the first determining module is used for determining a target page requested by the page request according to the received page request; the second determining module is used for determining target components contained in the target page according to the configuration information of the target page; the acquisition module is used for acquiring a first file of the target component from a database, wherein the first file is a resource file of the target component; the loading module is used for loading the target component according to the first file and a second file imported in a global variable form, wherein the second file comprises a package file on which the target component depends; and the rendering module is used for rendering the target page according to the target component so as to respond to the page request.

In a third aspect, the present disclosure provides a computer readable medium having stored thereon a computer program which when executed by a processing device performs the steps of a page response method.

In a fourth aspect, there is provided an electronic device comprising: a storage device having a computer program stored thereon; processing means for executing said computer program in said storage means to implement the steps of the page response method.

In the above technical solution, according to the received page request, a target page requested by the page request is determined, a target component included in the target page is determined according to configuration information of the target page, and a first file of the target component is obtained from a database, so that the target component can be loaded according to the first file and a second file imported in a global variable form, and then the target page is rendered according to the target component to respond to the page request. Through the technical scheme, when the target page is rendered, all components do not need to be loaded, so that the components can be loaded as required, and resources occupied by the loaded components can be reduced. Meanwhile, the package file relied by the target component can be imported in a global variable form, so that file sharing among components under different projects can be realized, package of the package file relied by the component is not needed, the data occupation amount of the file of the component is reduced, expansion and dynamic loading of the component are facilitated, the accuracy and instantaneity of page response are improved, the resource consumption of the loaded component can be further reduced, and the application range of the page response method is improved.

Additional features and advantages of the present disclosure will be set forth in the detailed description which follows.

Drawings

The above and other features, advantages, and aspects of embodiments of the present disclosure will become more apparent by reference to the following detailed description when taken in conjunction with the accompanying drawings. The same or similar reference numbers will be used throughout the drawings to refer to the same or like elements. It should be understood that the figures are schematic and that elements and components are not necessarily drawn to scale.

In the drawings:

FIG. 1 is a flow chart of a page response method provided in accordance with an embodiment of the present disclosure;

FIG. 2 is a flow chart of a page response method provided in accordance with an embodiment of the present disclosure;

FIG. 3 is a flow chart of a page response method provided in accordance with an embodiment of the present disclosure;

FIG. 4 is a block diagram of a page response device provided in accordance with an embodiment of the present disclosure;

FIG. 5 is a block diagram of a page response device provided in accordance with an embodiment of the present disclosure;

FIG. 6 is a block diagram of a page response device provided in accordance with an embodiment of the present disclosure;

FIG. 7 is a block diagram of a page response device provided in accordance with an embodiment of the present disclosure;

FIG. 8 is a block diagram of a page response device provided in accordance with an embodiment of the present disclosure;

FIG. 9 is a block diagram of a page response device provided in accordance with an embodiment of the present disclosure;

fig. 10 is a schematic structural view of an electronic device provided according to an embodiment of the present disclosure.

Detailed Description

Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While certain embodiments of the present disclosure have been shown in the accompanying drawings, it is to be understood that the present disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein, but are provided to provide a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are for illustration purposes only and are not intended to limit the scope of the present disclosure.

It should be understood that the various steps recited in the method embodiments of the present disclosure may be performed in a different order and/or performed in parallel. Furthermore, method embodiments may include additional steps and/or omit performing the illustrated steps. The scope of the present disclosure is not limited in this respect.

The term "including" and variations thereof as used herein are intended to be open-ended, i.e., including, but not limited to. The term "based on" is based at least in part on. The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments. Related definitions of other terms will be given in the description below.

It should be noted that the terms "first," "second," and the like in this disclosure are merely used to distinguish between different devices, modules, or units and are not used to define an order or interdependence of functions performed by the devices, modules, or units.

It should be noted that references to "one", "a plurality" and "a plurality" in this disclosure are intended to be illustrative rather than limiting, and those of ordinary skill in the art will appreciate that "one or more" is intended to be understood as "one or more" unless the context clearly indicates otherwise.

The names of messages or information interacted between the various devices in the embodiments of the present disclosure are for illustrative purposes only and are not intended to limit the scope of such messages or information.

Fig. 1 is a flowchart of a page response method according to an embodiment of the disclosure, as shown in fig. 1, where the method includes:

in step 11, a target page requested by the page request is determined according to the received page request. For example, the target page, i.e., the page to which the URL is located, may be determined from the URL in the page request.

In step 12, a target component included in the target page is determined according to the configuration information of the target page.

Wherein the configuration information may be generated when the target page is created. For example, the user may create and configure the target page through the UI user interface, and if the user may select a component that needs to be added to the target page according to actual needs, after the target page is created, each component in the target page may be recorded in the configuration information, so that the target component may be determined according to the configuration information.

In step 13, a first file of a target component is obtained, where the first file is a resource file of the target component.

Wherein the first file of the component may be stored in a database, which may be a MongoDB database, for example, the first file may be read from the database when the component is displayed in the page editing interface, so that the component is displayed for the user.

In step 14, the target component is loaded according to the first file and a second file imported in the form of a global variable, wherein the second file may be a package file, and the second file includes a package file on which the target component depends.

In this embodiment, package files that components depend on may be imported in the form of global variables, for example, package file importation may be performed by configuring dependent package files as global variables when the component code is written to package the component code. For example, the module packager may be configured, set up its external interface and reference the external dependency manner. For example, the global variable names corresponding to the package files when the package files are imported in the form of global variables can be configured, for example, the package file A can be configured into global variable globalA through the configuration of 'globalA', and when the package files imported in the form of global variables are used, the package files can be used based on the global variable names by obtaining the configuration to determine the global variable names corresponding to the package files.

For example, the target component may be packaged in the above manner, and then the second file includes the package file on which the target component depends, so that the package file on which the target component depends does not need to be loaded when the target component is loaded. In another embodiment, in order to further facilitate loading of the components, each component may adopt the above manner when the creation is completed and packaging is performed, so that the second file may include a package file on which a plurality of components depend, which not only can realize sharing of a common package file among a plurality of components, but also can reduce the data volume corresponding to loading of each component and improve the loading efficiency of the components.

As described in the background art, in the prior art, component codes need to be packaged, so as to realize code sharing, and the component codes need to be compiled together with a system to which the method is applied, so that dynamic loading of the components cannot be realized. In the method, the package file is imported in the form of a global variable, so that the resource file of the component can be dynamically loaded, the dynamic loading of the component is realized, and the loading and sharing of the component are facilitated.

In step 15, the target page is rendered according to the target component to respond to the page request.

For example, the page rendering manner according to the component may be performed by an existing renderer, so as to obtain a page for displaying to the user, which is not described herein.

Optionally, the method may further comprise the steps of:

the first file of the target component is monitored, for example, by a monitoring plug-in to monitor changes in files, folders, etc.

And under the condition that the first file change of the target component is determined, packaging related information of the target component to obtain an updated first file of the target component, wherein the related information comprises configuration information of the target component.

The configuration information may be a descriptive file, which is used to describe related information of the component, such as component identification, classification of the component, configurable parameters of the component, and the like, and when a user creates a page based on the component, the component may be configured based on the descriptive file. Optionally, the related information may further include style information of the component, such as a CSS (Cascading Style Sheets, cascading style sheet) file. Because the package file is imported in the form of the global variable in the scheme provided by the disclosure, when the related information of the target component is packaged, the package file on which the component depends is not required to be packaged in the packaged file, so that the data redundancy can be effectively reduced, and the data occupation amount of the first file obtained after the component is packaged can be reduced.

And replacing the first file of the target component in the database with the updated first file.

In the embodiment, the real-time performance of the first files of all the components in the database is ensured by monitoring the change of the first files of the components and updating the first files in the database when the first files are changed. Moreover, through the technical scheme, the first file of the component can be free from including the dependent package file, the component can be dynamically loaded into a system applied by the method, and is free from compiling with the system, so that the development of the component is facilitated, the cooperative sharing of the development of the component is improved, and the application range of the method is improved.

Optionally, the method may be applied to a server cluster, and the method may further include:

in the event of a first file update of the target component, a server of the server cluster that loaded the first file of the target component is determined. The IP address, the port number and the like of the equipment in the server cluster can be acquired in a service discovery mode, so that the server loaded with the first file of the target component can be further determined.

And deleting the first file of the target component loaded in the server.

In this embodiment, since the first file of the target component has been updated, the first file of the target component loaded by the server before that is not the latest version, and the first file of the target component loaded in the server is deleted at this time, it is avoided that the subsequent server renders the target page based on the first file of the old version, and a foundation is provided for ensuring instantaneity and accuracy of the first file and the target page of the target component. Meanwhile, whether the first file of the target component is out of date can be conveniently determined by determining whether the first file of the target component exists or not, and accuracy of the target page is further guaranteed.

Optionally, the method may further include:

and storing the rendered target page in a local cache. Therefore, when the user requests the target page again later, the response efficiency of the target page is facilitated to be improved.

Optionally, before the step 12 of determining the target component included in the target page according to the configuration information of the target page, as shown in fig. 2, on the basis of fig. 1, the method may further include:

in step 21, the cache page corresponding to the page identifier of the target page is queried from the local cache.

Wherein the page identification may be determined based on the page ID and one or more of the terminal language type, the operating system type, and the APP version type, etc. The page identity is obtained by concatenating the ID of the page with the terminal language type, for example. It should be noted that the page identifier uniquely identifies a page.

And executing the step 12 of determining the target components contained in the target page according to the configuration information of the target page under the condition that the cache page is not queried.

In this embodiment, if the cache page is not queried, it means that there is no page corresponding to the page identifier in the local cache, and at this time, the page needs to be rendered to respond to the page request, and then step 12 and

subsequent steps

13 and 14 of determining, according to the configuration information of the target page, the target component included in the target page are executed, so as to implement rendering of the target page.

In the embodiment, whether the corresponding page exists or not is firstly queried from the local cache, and the target assembly is loaded when the page does not exist, so that the target page is rendered according to the target assembly, repeated rendering of the target page can be effectively avoided, multiplexing of the target page is realized, response efficiency of the page is improved, and resource consumption of a server is saved.

Optionally, in the actual usage scenario, the user may set the page to be offline, that is, the page is not used any more, and before the step 12 of determining, according to the configuration information of the target page, the target component included in the target page, the method may further include: determining whether the target page is offline, executing the step 12 of determining the target component contained in the target page according to the configuration information of the target page when the target page is not offline, and redirecting to the offline page when the target page is offline, and responding to the page request by taking the offline page as the target page.

The above embodiments are merely exemplary illustrations and do not limit the present disclosure. For example, in another embodiment, the step 12 of determining, according to the configuration information of the target page, the target component included in the target page and the subsequent steps may be performed simultaneously in combination with the above embodiments, for example, in a case that the target page is not offline and the cache page corresponding to the page identifier of the target page is not queried from the local cache. The order of execution of determining whether a page is down and querying a cached page from a local cache is not limited in this disclosure.

In another application scenario, in order to facilitate the user to quickly and conveniently create pages, for some general pages, a page template, such as a login page, a detail page, etc., may be provided for the user, and the user may design the page based on the page template. Accordingly, the method may further comprise:

and determining a target template corresponding to the target page according to the received page request, and loading the target template. For example, the page request may also carry a corresponding template ID of the target page, and the target template may be directly located based on the template ID.

One exemplary embodiment of rendering a target page according to a target component may include:

and rendering the target page according to the target component and the target template.

In the embodiment, the target template corresponding to the target page is determined, so that the target page can be rendered according to the target component and the target template, the efficiency and accuracy of rendering the target page can be improved, the efficiency of page response can be further improved, and the use requirements of high instantaneity and high reliability in page request are met.

Optionally, in the actual usage scenario, a corresponding product configuration may also be set for the target page, if the page is applied to the product P, it may be determined whether the product configuration of the product P corresponding to the target page is loaded, after the product configuration of the product P is loaded, the target page is rendered according to the target component and the target template based on the rendering modes corresponding to the product configuration of the product P, where the rendering modes corresponding to different products may be the same or different, and may be set according to the actual usage scenario, and this disclosure is not limited.

Optionally, the method may further include:

and under the condition that the cache page is inquired, determining whether the cache page is out of date.

As described above, querying the cached page indicates that the rendered target page is stored in the local cache. Meanwhile, since each component has an irregular update, a situation that one or more components contained in the target page are updated after the target page is stored occurs, and in this case, the cache page is out of date due to the update of the components, that is, the cache page is not the latest version.

Optionally, an exemplary implementation of the determining whether the cache page expires may include:

determining whether the cached page is out of date according to at least one of:

whether the target components contained in the target page are all loaded or not;

and the latest loading time corresponding to the target component and the rendering time of the cache page are sequenced.

For example, under the condition that all target components contained in a target page are loaded and the latest loading time corresponding to the target components is earlier than the rendering time of the cache page, determining that the cache page is not expired;

Determining that the cache page is out of date if it is determined that the cache page meets any one of:

the target components contained in the target page are not all loaded;

and the latest loading time corresponding to the target component is not earlier than the rendering time of the cache page.

For example, to improve the efficiency of determining whether a cache page is out of date, the determination may be made as follows:

first, it is determined whether the target components contained in the target page are all loaded.

Based on the above, when the target component is updated, deleting the first file in the server loaded with the first file of the target component can determine whether the target component to be updated exists in the target components of the target page by determining whether all target components contained in the target page are loaded.

And then, under the condition that all the target components contained in the target page are loaded, determining the latest loading moment corresponding to the target components. The latest loading time corresponding to the target component is the latest time among the loading times according to the target components. For example, the loading time of each target component may be determined separately, the latest time of each comparison is recorded by a loop comparison mode, and the latest loading time is obtained after the loop comparison is completed.

If the latest loading time is earlier than the rendering time of the cache page, determining that the cache page is not expired; and if the target component is not loaded completely or the latest loading time is not earlier than the rendering time of the cache page, determining that the cache page is out of date. The rendering time of the cache page may be recorded when the cache page is rendered, and stored together when the cache page is stored in the local cache.

If the latest loading time is earlier than the rendering time of the cache page, it means that each target component is loaded before the cache page is rendered, that is, after the cache page is rendered, each corresponding target component is unchanged, and at this time, the cache page can be directly applied, that is, the cache page is not expired.

If it is determined that the target components are not loaded completely or the latest loading time is not earlier than the rendering time of the cache page, the fact that updated target components exist in the target components contained in the cache page after the cache page is rendered is indicated, and the fact that the cache page is out of date is indicated. After loading is completed, the target components which are not loaded can be re-rendered according to the target components contained in the target page, so that the instantaneity and the accuracy of the target page can be ensured.

Optionally, as described above, the exemplary embodiment of determining whether the cache page is expired may include:

the latest loading time corresponding to the target component and the sequence of the rendering time of the cache page;

and the loading time of the target template and the rendering time of the cache page are sequenced.

For example, when it is determined that the loading time of the target template is earlier than the rendering time of the cache page, all target components contained in the target page are loaded, and the latest loading time corresponding to the target components is earlier than the rendering time of the cache page, it is determined that the cache page is not expired;

the loading time of the target template is not earlier than the rendering time of the cache page;

the target components contained in the target page are not all loaded;

For example, it may be first determined whether the loading time of the target template is earlier than the rendering time of the cache page;

determining whether all target components contained in the target page are loaded or not under the condition that the loading time of the target template is earlier than the rendering time of the cache page;

and under the condition that the loading time of the target template is not earlier than the rendering time of the cache page, determining that the cache page is out of date.

In this embodiment, if the loading time of the target template is earlier than the rendering time of the cache page, it means that the target template is not updated after the cache page is rendered, and the cache page will not expire due to the target template, and then a subsequent determination of the target component may be performed to further determine whether the cache page is expired, where the detailed description is omitted herein according to the specific manner of determining whether the cache page is expired based on each target component. If the loading time of the target template is not earlier than the rendering time of the cache page, the target template is not rendered based on the loaded target template when the cache page is rendered, that is, the target template is updated after the cache page is rendered, at this time, it can be determined that the cache page is expired, and the target template can be reloaded to re-render the target page.

Through the steps, whether the queried cache page is out of date can be determined, and if the cache page is not out of date, the cache page is used as the target page so as to respond to the page request.

In this embodiment, in the case that the cache page is queried, whether the cache page is expired is determined to determine whether the cache page can be used as a target page to respond to the page request, and in the case that the cache page is not expired is determined, the cache page can be directly output from the local cache to respond to the page request, so that an unnecessary rendering process can be effectively avoided, the efficiency of page response can be improved, and the performance of the server can be improved.

Optionally, under the condition that the cache page is out of date, the target page can be re-rendered in the above manner, and the cache page in the local cache is updated to the re-rendered target page, so that subsequent response is facilitated, instantaneity of the page in the local cache is ensured, and page response efficiency is further improved.

Optionally, in step 14, according to the first file and the second file imported in the form of global variables, an exemplary embodiment of loading the target component is as follows, which may include:

And determining the dependent component of the target component according to the dependent relation between the target component and the preset component.

Wherein the dependency relationship between components is set at the time of component development. For example, a global registration component may be supported in the VUE framework whereby component registration may be accomplished once and may be applied multiple times. Wherein the component can be uniquely identified by a component name. Wherein the dependent components include directly dependent components and indirectly dependent components. For example, when a component is developed, the component a depends on the component B, the component B depends on the component C, and when the target component is a, it depends on the components B and C, and when the target component is B, it depends on the component C.

And loading the dependent component and the target component according to the dependent relation according to the first file of the target component, the first file of the dependent component and the second file imported in the form of a global variable, wherein the second file also comprises a package file on which the dependent component depends, so that the loading of the dependent component can be completed based on the package file on which the dependent component depends in the second file.

The dependent components and the target components may be loaded sequentially in the order of the dependent relationships. In the above example, the dependency relationship is that the component a depends on the component B, and the component B depends on the component C, and when loading, the first files of the components C, B, A may be loaded in the order of preferentially loading the dependent components, so that the use of the dependent components and the target components is ensured in combination with the package files imported in the form of global variables.

By the technical scheme, the dependency relationship among the components is considered, and based on the mode of completely registering the components, the use of the target component can be ensured only by loading the file of the target component after loading the resource file of the dependent component, so that the time and resource consumption caused by loading unnecessary resource files are avoided, and the normal use of the target component can be ensured. Meanwhile, the dynamic addition of the components can be supported, the expansibility of the components is improved, and the use experience of users is further improved.

The above-described flow is described in detail below with reference to an embodiment. As shown in the figure 3 of the drawings,

in S1, determining a target page requested by a page request according to the received page request;

in S2, determining whether a cache page corresponding to a page identifier of a target page is queried from a local cache, if so, turning to S3, otherwise, turning to S4;

in S3, determining whether the cache page is out of date, if so, turning to S4, otherwise, turning to S5;

in S5, taking the cache page as a target page to respond to the page request;

in S4, determining target components contained in the target page according to the configuration information of the target page;

in S6, determining whether the target page is offline, if so, turning to S7, and if not, turning to S8;

In S7, redirecting to a lower line page, and responding to the page request by taking the lower line page as a target page;

in S8, determining whether loading of each target component is completed, if not, loading the target components and turning to S8, and if yes, turning to S9;

in S9, determining whether a target template corresponding to the target page is loaded, if not, loading the target template and turning to S9, and if yes, turning to S10;

in S10, determining whether the product configuration corresponding to the target page is loaded, if not, loading the product configuration, and turning to S10, if so, turning to S101;

in S101, a target page is rendered according to the target component and the target template, in order to respond to the page request, and the rendered target page is stored in the local cache.

The present disclosure also provides a page response device, as shown in fig. 4, the device 10 includes:

a first determining module 101, configured to determine, according to a received page request, a target page requested by the page request;

a second determining module 102, configured to determine a target component included in the target page according to configuration information of the target page;

an obtaining module 103, configured to obtain a first file of the target component from a database, where the first file is a resource file of the target component;

The loading module 104 is configured to load the target component according to the first file and a second file imported in a global variable form, where the second file includes a package file on which the target component depends;

and the rendering module 105 is used for rendering the target page according to the target component so as to respond to the page request.

Optionally, the apparatus further comprises:

the monitoring module is used for monitoring the first file of the target component;

the packaging module is used for packaging the related information of the target component under the condition that the first file of the target component is determined to be changed, so as to obtain an updated first file of the target component, wherein the related information comprises configuration information of the target component;

and the updating module is used for replacing the first file of the target component with the updated first file.

Optionally, as shown in fig. 5, the apparatus 10 further includes:

a query module 201, configured to query a cache page corresponding to a page identifier of the target page from a local cache before the second determining module determines, according to configuration information of the target page, a target component included in the target page;

In the case that the cache page is not queried, the second determining module 102 determines, according to the configuration information of the target page, a target component included in the target page.

Optionally, as shown in fig. 6, the apparatus 10 further includes:

a third determining module 301, configured to determine, if the cached page is expired, if the cached page is queried;

and a fourth determining module 302, configured to, in case the cached page is not expired, use the cached page as the target page, so as to respond to the page request.

Optionally, the third determining module includes:

a first determination submodule for determining whether the cache page is out of date according to at least one of:

Optionally, the loading module includes:

the second determining submodule is used for determining a dependent component of the target component according to the dependent relation between the target component and a preset component;

and the loading sub-module is used for loading the dependent component and the target component according to the dependent relation according to the first file of the target component, the first file of the dependent component and the second file, wherein the second file also comprises a package file on which the dependent component depends.

Optionally, as shown in fig. 7, the apparatus 10 further includes:

a fifth determining module 401, configured to determine, according to the received page request, a target template corresponding to the target page, and load the target template;

the rendering module 105 is configured to:

Optionally, the third determining module includes:

a third determination submodule for determining whether the cache page is out of date according to at least one of the following:

and the loading time of the target template and the rendering time of the cache page are sequenced. .

Optionally, as shown in fig. 8, the apparatus 10 further includes:

the storage module 501 is configured to store the rendered target page in a local cache.

Optionally, the apparatus is applied to a server cluster, as shown in fig. 9, and the apparatus 10 further includes:

a sixth determining module 701, configured to determine, in a case where the first file of the target component is updated, a server in the server cluster that loads the first file of the target component;

A deleting module 702, configured to delete the first file of the target component loaded in the server.

Referring now to fig. 10, a schematic diagram of an electronic device 600 suitable for use in implementing embodiments of the present disclosure is shown. The terminal devices in the embodiments of the present disclosure may include, but are not limited to, mobile terminals such as mobile phones, notebook computers, digital broadcast receivers, PDAs (personal digital assistants), PADs (tablet computers), PMPs (portable multimedia players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and the like, and stationary terminals such as digital TVs, desktop computers, and the like. The electronic device shown in fig. 10 is merely an example and should not be construed to limit the functionality and scope of use of the disclosed embodiments.

As shown in fig. 10, the electronic device 600 may include a processing means (e.g., a central processing unit, a graphic processor, etc.) 601, which may perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM) 602 or a program loaded from a storage means 608 into a Random Access Memory (RAM) 603. In the RAM 603, various programs and data required for the operation of the electronic apparatus 600 are also stored. The processing device 601, the ROM 602, and the RAM 603 are connected to each other through a bus 604. An input/output (I/O) interface 605 is also connected to bus 604.

In general, the following devices may be connected to the I/O interface 605: input devices 606 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, and the like; an output device 607 including, for example, a Liquid Crystal Display (LCD), a speaker, a vibrator, and the like; storage 608 including, for example, magnetic tape, hard disk, etc.; and a communication device 609. The communication means 609 may allow the electronic device 600 to communicate with other devices wirelessly or by wire to exchange data. While fig. 10 shows an electronic device 600 having various means, it is to be understood that not all of the illustrated means are required to be implemented or provided. More or fewer devices may be implemented or provided instead.

In particular, according to embodiments of the present disclosure, the processes described above with reference to flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a non-transitory computer readable medium, the computer program comprising program code for performing the method shown in the flow chart. In such an embodiment, the computer program may be downloaded and installed from a network via communication means 609, or from storage means 608, or from ROM 602. The above-described functions defined in the methods of the embodiments of the present disclosure are performed when the computer program is executed by the processing device 601.

It should be noted that the computer readable medium described in the present disclosure may be a computer readable signal medium or a computer readable storage medium, or any combination of the two. The computer readable storage medium can be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples of the computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this disclosure, a computer-readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present disclosure, however, the computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, with the computer-readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: electrical wires, fiber optic cables, RF (radio frequency), and the like, or any suitable combination of the foregoing.

In some implementations, the server may communicate using any currently known or future developed network protocol, such as HTTP (HyperText Transfer Protocol ), and may be interconnected with any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include a local area network ("LAN"), a wide area network ("WAN"), the internet (e.g., the internet), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future developed networks.

The computer readable medium may be contained in the electronic device; or may exist alone without being incorporated into the electronic device.

The computer readable medium carries one or more programs which, when executed by the electronic device, cause the electronic device to: determining a target page requested by a page request according to the received page request; determining a target component contained in the target page according to the configuration information of the target page; acquiring a first file of the target component, wherein the first file is a resource file of the target component; loading the target component according to the first file and a second file imported in a global variable form, wherein the second file comprises a package file on which the target component depends; and rendering the target page according to the target component so as to respond to the page request.

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

The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The modules described in the embodiments of the present disclosure may be implemented in software or hardware. The name of the module is not limited to the module itself in some cases, for example, the first determining module may also be described as "a module for determining, according to a received page request, a target page requested by the page request".

The functions described above herein may be performed, at least in part, by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: a Field Programmable Gate Array (FPGA), an Application Specific Integrated Circuit (ASIC), an Application Specific Standard Product (ASSP), a system on a chip (SOC), a Complex Programmable Logic Device (CPLD), and the like.

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

According to one or more embodiments of the present disclosure, there is provided a page response method, wherein the method includes:

determining a target page requested by a page request according to the received page request;

determining a target component contained in the target page according to the configuration information of the target page;

acquiring a first file of the target component, wherein the first file is a resource file of the target component;

loading the target component according to the first file and a second file imported in a global variable form, wherein the second file comprises a package file on which the target component depends;

and rendering the target page according to the target component so as to respond to the page request.

According to one or more embodiments of the present disclosure, the method further comprises:

monitoring a first file of the target component;

under the condition that the first file change of the target component is determined, packaging related information of the target component to obtain an updated first file of the target component, wherein the related information comprises configuration information of the target component;

and replacing the first file of the target component with the updated first file.

According to one or more embodiments of the present disclosure, before the step of determining the target component included in the target page according to the configuration information of the target page, the method further includes:

inquiring a cache page corresponding to the page identifier of the target page from a local cache;

and under the condition that the cache page is not queried, executing the step of determining a target component contained in the target page according to the configuration information of the target page.

under the condition that the cache page is inquired, determining whether the cache page is out of date;

and under the condition that the cache page is not expired, taking the cache page as the target page to respond to the page request.

According to one or more embodiments of the present disclosure, the determining whether the cache page is out of date includes:

According to one or more embodiments of the present disclosure, the loading the target component according to the first file and the second file imported in the form of global variables includes:

determining a dependent component of the target component according to the dependent relation between the target component and a preset component;

and loading the dependent component and the target component according to the dependent relation according to the first file of the target component, the first file of the dependent component and the second file imported in the form of global variables, wherein the second file also comprises a package file on which the dependent component depends.

determining a target template corresponding to the target page according to the received page request, and loading the target template;

the rendering the target page according to the target component includes:

According to one or more embodiments of the present disclosure, the method further comprises: and storing the rendered target page in a local cache.

According to one or more embodiments of the present disclosure, the method is applied to a server cluster, the method further comprising:

determining a server of the server cluster loaded with the first file of the target component under the condition that the first file of the target component is updated;

and deleting the first file of the target component loaded in the server.

According to one or more embodiments of the present disclosure, there is provided a page response apparatus, wherein the apparatus includes:

the first determining module is used for determining a target page requested by the page request according to the received page request;

the second determining module is used for determining target components contained in the target page according to the configuration information of the target page;

The acquisition module is used for acquiring a first file of the target component from a database, wherein the first file is a resource file of the target component;

the loading module is used for loading the target component according to the first file and a second file imported in a global variable form, wherein the second file comprises a package file on which the target component depends;

and the rendering module is used for rendering the target page according to the target component so as to respond to the page request.

According to one or more embodiments of the present disclosure, there is provided a computer readable medium having stored thereon a computer program which, when executed by a processing device, implements the steps of the page response method described above.

According to one or more embodiments of the present disclosure, there is provided an electronic device including:

a storage device having a computer program stored thereon; processing means for executing said computer program in said storage means to implement the steps of the page response method described above.

The foregoing description is only of the preferred embodiments of the present disclosure and description of the principles of the technology being employed. It will be appreciated by persons skilled in the art that the scope of the disclosure referred to in this disclosure is not limited to the specific combinations of features described above, but also covers other embodiments which may be formed by any combination of features described above or equivalents thereof without departing from the spirit of the disclosure. Such as those described above, are mutually substituted with the technical features having similar functions disclosed in the present disclosure (but not limited thereto).

Moreover, although operations are depicted in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order. In certain circumstances, multitasking and parallel processing may be advantageous. Likewise, while several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of the present disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are example forms of implementing the claims. The specific manner in which the various modules perform the operations in the apparatus of the above embodiments have been described in detail in connection with the embodiments of the method, and will not be described in detail herein.

Claims

1. A page response method, the method comprising:

rendering the target page according to the target component to respond to the page request;

before the step of determining the target components contained in the target page according to the configuration information of the target page, the method further comprises:

executing the step of determining a target component contained in the target page according to the configuration information of the target page under the condition that the cache page is not queried;

wherein determining whether the cached page is stale is based on at least one of:

2. The method of claim 1, wherein the method further comprises:

monitoring a first file of the target component;

3. The method of claim 1, wherein the method further comprises:

4. The method of claim 1, wherein the loading the target component from the first file and the second file imported in the form of global variables comprises:

5. The method of any of claims 1-4, wherein the method further comprises:

the rendering the target page according to the target component includes:

6. The method of claim 5, wherein the determining whether the cache page is stale comprises:

7. The method of claim 1, wherein the method further comprises:

and storing the rendered target page in a local cache.

8. The method of any of claims 1-4, wherein the method is applied to a server cluster, the method further comprising:

and deleting the first file of the target component loaded in the server.

9. A page response device, the device comprising:

The rendering module is used for rendering the target page according to the target component so as to respond to the page request;

the apparatus further comprises:

the query module is used for querying a cache page corresponding to the page identifier of the target page from a local cache before the second determination module determines the target component contained in the target page according to the configuration information of the target page;

under the condition that the cache page is not queried, the second determining module determines a target component contained in the target page according to the configuration information of the target page;

10. A computer readable medium having stored thereon a computer program which, when executed by a processing device, implements the steps of the method of any of claims 1-8.

11. An electronic device, comprising:

a storage device having a computer program stored thereon;

processing means for executing said computer program in said storage means to carry out the steps of the method according to any one of claims 1-8.