Method for generating front-end page and related device

Abstract

Embodiments of the present application provide a front-end page generation method and related device, the method comprising: creating an entity corresponding to entity information according to the obtained entity information; adding an element to the entity according to the configured element, the element belonging to the entity; configuring a tree structure according to the entity and the obtained entity relationship information corresponding to the entity, so that a tree node in the tree structure corresponds to the entity, and the connection relationship of each tree node in the tree structure corresponds to the entity relationship information; adding the content of the element to the tree node corresponding to the entity to which the element belongs in the tree structure according to the obtained content of the element, to obtain tree configuration data; and generating a front-end page based on the tree configuration data. The technical solution of the embodiments of the present application can greatly reduce the development cost of the front-end project, and can significantly improve the development efficiency of the front-end project.

Description

Technical Field

[0001] This application relates to the field of page development technology, and more specifically, to a method and related apparatus for generating front-end pages. Background Technology

[0002] Currently, front-end project development involves two processes: front-end developers creating the front-end pages, and back-end developers creating the management backend. Furthermore, front-end and back-end developers need to perform API integration testing to ensure the front-end pages can retrieve data from the backend for display. Therefore, this process requires multiple developers and a significant amount of time to complete, resulting in high costs and low efficiency. Summary of the Invention

[0003] The embodiments of this application provide a method and related apparatus for generating front-end pages, which can at least reduce the development cost of front-end projects and significantly improve the development efficiency of front-end projects.

[0004] Other features and advantages of this application will become apparent from the following detailed description, or may be learned in part from practice of this application.

[0005] According to one aspect of the embodiments of this application, a method for generating a front-end page is provided. The method includes: creating an entity corresponding to the obtained entity information; adding an element to the entity according to configured elements, wherein the element belongs to the entity; configuring a tree structure according to the entity and obtained entity relationship information corresponding to the entity, such that the tree nodes in the tree structure correspond to the entities, and the connection relationship of each tree node in the tree structure corresponds to the entity relationship information; adding the content of the obtained element to the tree node corresponding to the entity to which the element belongs in the tree structure, thereby obtaining tree configuration data; and generating a front-end page based on the tree configuration data.

[0006] According to one aspect of the embodiments of this application, a front-end page generation apparatus is provided. The apparatus includes: a creation unit, configured to create an entity corresponding to the entity information based on acquired entity information; a first adding unit, configured to add an element to the entity based on configured elements, wherein the element belongs to the entity; a configuration unit, configured to configure a tree structure based on the entity and acquired entity relationship information corresponding to the entity, such that the tree nodes in the tree structure correspond to the entities, and the connection relationship of each tree node in the tree structure corresponds to the entity relationship information; a second adding unit, configured to add the content of the element to the corresponding tree node of the entity to which the element belongs in the tree structure based on the acquired content of the element, thereby obtaining tree configuration data; and a generation unit, configured to generate a front-end page based on the tree configuration data.

[0007] In some embodiments of this application, based on the foregoing scheme, the generation unit is configured to: obtain a target skin selected from a front-end skin library, the front-end skin library including multiple skins; load the tree configuration data into the target skin to obtain the front-end page.

[0008] In some embodiments of this application, based on the foregoing scheme, before obtaining the target skin selected from the front-end skin library, the generation unit is further configured to: determine the skin that matches the tree configuration data from the front-end skin library as the recommended skin; push a skin list including the recommended skin; the generation unit is configured to: obtain the target skin selected from the skin list.

[0009] In some embodiments of this application, based on the foregoing scheme, the generation unit is configured to: determine from the front-end skin library a skin that matches the width and depth of the tree structure as a candidate recommended skin; and determine from the candidate recommended skin a skin that matches an element in the entity as a recommended skin.

[0010] In some embodiments of this application, based on the foregoing scheme, before generating the front-end page based on the tree configuration data, the second adding unit is further configured to: save the tree configuration data to the tree configuration system; the generating unit is configured to: generate the front-end page according to the tree configuration data obtained from the tree configuration system.

[0011] In some embodiments of this application, based on the foregoing scheme, the tree configuration system is used by multiple users, the tree configuration system includes multiple tree configuration data, and at least one of the tree configuration data in the tree configuration system is isolated or shared among the multiple users of the tree configuration system.

[0012] In some embodiments of this application, based on the foregoing scheme, the tree configuration system further includes multiple entities created and multiple elements configured, and at least one entity and at least one element in the tree configuration system are isolated or shared among multiple users of the tree configuration system.

[0013] In some embodiments of this application, based on the foregoing scheme, before generating the front-end page based on the tree configuration data, the second adding unit is further configured to: export the tree configuration data to obtain a configuration data file; the generating unit is configured to: generate the front-end page based on the configuration data file.

[0014] In some embodiments of this application, based on the foregoing scheme, the second adding unit is configured to: when the content of an element is obtained, determine the element type corresponding to the element; verify the content of the element according to the element type to determine whether the content of the element is valid; if the content of the element is valid, add the content of the element to the tree node corresponding to the entity to which the element belongs in the tree structure to obtain tree configuration data.

[0015] According to one aspect of the embodiments of this application, a computer-readable medium is provided having a computer program stored thereon, which, when executed by a processor, implements the front-end page generation method as described in the above embodiments.

[0016] According to one aspect of the embodiments of this application, an electronic device is provided, including: one or more processors; and a storage device for storing one or more programs, which, when executed by the one or more processors, cause the one or more processors to implement the front-end page generation method as described in the above embodiments.

[0017] In the technical solutions provided by some embodiments of this application, when building a front-end page, relevant personnel only need to first create the various entities required for the page in the system, configure the elements contained in the entities, then provide entity relationship information, and use the entities and entity relationship information to configure the tree structure containing tree nodes. Next, the content of the elements is provided to continue configuring the corresponding tree nodes. Therefore, the entire front-end page generation process is basically achieved through user configuration, and almost no code writing or debugging process is involved. While allowing flexible customization of the front-end page configuration, it greatly reduces the development cost of the front-end project and significantly improves the development efficiency of the front-end project.

[0018] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and do not limit this application. Attached Figure Description

[0019] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application. It is obvious that the drawings described below are merely some embodiments of this application, and those skilled in the art can obtain other drawings based on these drawings without any inventive effort. In the drawings:

[0020] Figure 1 This diagram illustrates the user interface for implementing a front-end page in related technologies.

[0021] Figure 2 A schematic diagram of an exemplary system architecture to which the technical solutions of the embodiments of this application can be applied is shown;

[0022] Figure 3 A schematic diagram illustrating an application scenario according to an embodiment of this application is shown;

[0023] Figure 4 A schematic diagram illustrating an application scenario according to another embodiment of this application is shown;

[0024] Figure 5 A flowchart illustrating a method for generating a front-end page according to an embodiment of this application is shown;

[0025] Figure 6 A flowchart illustrating the construction of a front-end page by configuration according to an embodiment of this application is shown;

[0026] Figure 7 An embodiment according to this application is shown. Figure 6 A flowchart outlining the specific steps involved in creating an entity in the process;

[0027] Figure 8 A schematic diagram of a tree structure according to an embodiment of this application is shown;

[0028] Figure 9 A schematic diagram illustrating the relationship between entities and elements according to an embodiment of this application is shown;

[0029] Figure 10 A flowchart illustrating the generation of a front-end page based on tree-structured configuration data according to an embodiment of this application is shown;

[0030] Figure 11 An embodiment according to this application is shown. Figure 10 A flowchart detailing the steps preceding step 1030 and the steps in step 1030;

[0031] Figure 12 A flowchart illustrating the determination of a recommended skin according to an embodiment of this application is shown;

[0032] Figure 13 A flowchart illustrating the acquisition of tree configuration data according to an embodiment of this application is shown;

[0033] Figure 14 An architectural block diagram of a method for generating a front-end page according to an embodiment of this application is shown;

[0034] Figure 15 A schematic diagram illustrating the architectural principle of a front-end page generation method according to an embodiment of this application is shown.

[0035] Figure 16 A flowchart illustrating the overall process of constructing a front-end page by configuration according to an embodiment of this application is shown;

[0036] Figure 17 A block diagram of a front-end page generation apparatus according to an embodiment of this application is shown;

[0037] Figure 18 A schematic diagram of the structure of a computer system suitable for implementing the electronic device of the present application is shown. Detailed Implementation

[0038] Exemplary embodiments will now be described more fully with reference to the accompanying drawings. However, these exemplary embodiments can be implemented in many forms and should not be construed as limited to the examples set forth herein; rather, these embodiments are provided to make this application more comprehensive and complete, and to fully convey the concept of the exemplary embodiments to those skilled in the art.

[0039] Furthermore, the described features, structures, or characteristics can be combined in any suitable manner in one or more embodiments. Numerous specific details are provided in the following description to give a thorough understanding of embodiments of this application. However, those skilled in the art will recognize that the technical solutions of this application can be practiced without one or more of the specific details, or other methods, components, apparatuses, steps, etc., can be employed. In other instances, well-known methods, apparatuses, implementations, or operations are not shown or described in detail to avoid obscuring various aspects of this application.

[0040] The block diagrams shown in the accompanying drawings are merely functional entities and do not necessarily correspond to physically independent entities. That is, these functional entities can be implemented in software, in one or more hardware modules or integrated circuits, or in different network and / or processor devices and / or microcontroller devices.

[0041] The flowcharts shown in the accompanying drawings are merely illustrative and do not necessarily include all content and operations / steps, nor do they necessarily have to be performed in the described order. For example, some operations / steps can be broken down, while others can be combined or partially combined; therefore, the actual execution order may change depending on the specific circumstances.

[0042] Currently, front-end pages, also known as web pages, are one of the most important ways to display information in the internet age. With the rapid development of information technology, information changes constantly, making it increasingly necessary to quickly build front-end pages to improve information dissemination efficiency and reduce the various costs of front-end page projects.

[0043] In related technologies, the following two solutions were mainly used to implement the front-end page:

[0044] Option 1: Implement the page through visual interactive operations.

[0045] Figure 1 A schematic diagram of the operation interface for implementing the front-end page in related technologies is shown.

[0046] Please see Figure 1 The interface consists of three areas from left to right: the leftmost area is the component presentation area, the middle area is the page building area, and the rightmost area is the component configuration area. When using... Figure 1 When creating a front-end page using the interface shown, the user selects a component in the component presentation area and drags it to the page building area. The user can also move components within the page building area and configure their parameters in the component configuration area. Finally, the user can save the page created in the page building area to generate the final page.

[0047] The drawback of this first approach is that product operators frequently need to add new information to the pages. When the page style remains unchanged but the page content changes, directly modifying the page makes it difficult to guarantee the accuracy of the resulting page. For example, if a place on the page that should display a URL (Uniform Resource Locator) is modified to an invalid URL through editing, it will cause the page to malfunction.

[0048] Option 2: Front-end and back-end developers develop separately, and then conduct joint testing.

[0049] Specifically, front-end developers create the corresponding front-end pages, while back-end developers create the management backend. Front-end developers then interface with the management backend via APIs for joint testing. After product operations personnel complete the data configuration, the front-end pages retrieve backend data through the API for display. In IT terms, front-end developers are responsible for creating and generating the user interface; back-end engineers, a subcategory of software development engineers, are involved in software development, primarily responsible for platform design, API design, and feature implementation; and product operations personnel manage product content and users from three levels: content creation, user maintenance, and event planning.

[0050] The drawback of Option 2 is that the project requires a large number of developers, resulting in high implementation costs and low efficiency. Furthermore, it requires API calls between the front-end and back-end, and since APIs are dynamic, their performance is significantly weaker than that of static data, which may lead to poor page loading performance.

[0051] Therefore, this application provides a method for generating a front-end page, which can at least overcome the defects of the above two solutions to a certain extent, and also allows product operators to generate the front-end page through flexible configuration.

[0052] Figure 2 A schematic diagram of an exemplary system architecture to which the technical solutions of the embodiments of this application can be applied is shown. For example... Figure 1 As shown, the system architecture may include computer device 201, network 202, server 203, and terminal devices. Specifically, terminal devices may include laptops 204, tablets 205, smartphones 206, etc. Computer device 201 and all terminal devices can communicate with server 203 via network 202. Computer device 201 is used by users and has a management backend client deployed on it; server 203 has a management system corresponding to the management backend client. Figure 2 The system architecture shown illustrates the process of generating the front-end page as follows: First, the user creates entities in the management system using the management backend client deployed on computer device 201 and adds elements to these entities. Then, the user configures the tree nodes in the tree structure based on the entities and configures the relationships between the tree nodes in the tree structure based on the entity relationship information. Next, the user further configures the corresponding tree nodes by providing the content of the elements. This yields tree-structured configuration data, which can be generated either in the management system or in the management backend client. Finally, the management backend client can export the tree-structured configuration data to obtain the corresponding file, thereby generating the front-end page.

[0053] It should be understood that Figure 2 The number of terminal devices, networks, servers, and computer devices shown is merely illustrative. Depending on implementation needs, any number of terminal devices, networks, servers, and computer devices can be included. For example, server 203 could be a server cluster composed of multiple servers.

[0054] In some embodiments of this application, the front-end page is generated by loading tree-like configuration data onto a selected skin.

[0055] In some embodiments of this application, the generated front-end page is stored in the management system on server 203, and each terminal device can obtain the front-end page on server 203 through network 202 to browse the page.

[0056] In some embodiments of this application, the user performs a save operation on the management backend client to save the tree configuration data to the management system on the server 203. When the front-end page is displayed, it retrieves the tree configuration data from the management system and loads and displays it.

[0057] In some embodiments of this application, multiple computer devices corresponding to the management system on server 203 are set up. Each computer device is equipped with a management backend client. The management backend clients on each computer device can interact with the management system to configure relevant data, thereby generating pages.

[0058] In some embodiments of this application, the user of the management backend client is the product operations personnel of the frontend project.

[0059] It should be noted that, Figure 2 The example shown is only one embodiment of this application. Although Figure 2 In the embodiment, the front-end page generation process is achieved through the interaction between computer device 201 and server 203. However, in other embodiments of this application, the entire front-end page generation process can be achieved using any single device such as computer device 201 or server 203. When using a server for page generation, a monitor can be configured for the server. Although Figure 2 In this embodiment, the device used by the user to configure information is a computer device. However, in other embodiments of this application, the device used by the user to configure information can also be any device capable of receiving information, such as a smartphone. This application does not limit the scope of protection in any way, nor should it restrict the scope of protection of this application.

[0060] It is easy to understand that the front-end page generation method provided in this application embodiment is generally executed by a server, and correspondingly, the front-end page generation device is generally located in the server. However, in other embodiments of this application, the terminal device may also have similar functions to the server, thereby executing the front-end page generation scheme provided in this application embodiment.

[0061] Therefore, the embodiments of this application can be applied to terminals or servers. The server can be a standalone physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server providing basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN, and big data and artificial intelligence platforms. The terminal can be a smartphone, tablet, laptop, desktop computer, smart speaker, smartwatch, etc., but is not limited to these. The terminal and server can be directly or indirectly connected via wired or wireless communication, and this application does not impose any restrictions.

[0062] In some embodiments of this application, user-configured entities and / or elements are managed in a blockchain.

[0063] Blockchain is a novel application model of computer technologies such as distributed data storage, peer-to-peer transmission, consensus mechanisms, and cryptographic algorithms. Essentially, a blockchain is a decentralized database, a chain of data blocks linked together using cryptographic methods. Each data block contains information about a batch of network transactions, used to verify the validity of the information (anti-counterfeiting) and generate the next block. A blockchain can include an underlying platform, a platform product and service layer, and an application service layer.

[0064] The underlying blockchain platform can include processing modules such as user management, basic services, smart contracts, and operational monitoring. The user management module is responsible for managing the identity information of all blockchain participants, including maintaining public and private key generation (account management), key management, and maintaining the correspondence between user real identities and blockchain addresses (access management). Furthermore, under authorization, it monitors and audits transactions of certain real identities and provides risk control rule configuration (risk control audit). The basic services module is deployed on all blockchain node devices to verify the validity of business requests. After consensus is reached on valid requests, they are recorded in storage. For a new business request, the basic services first perform interface adaptation parsing and authentication (interface adaptation), and then encrypt the business information using a consensus algorithm (consensus management). After encryption, the data is transmitted completely and consistently to the shared ledger (network communication) and recorded and stored. The smart contract module is responsible for contract registration, issuance, triggering, and execution. Developers can define contract logic using a programming language and publish it to the blockchain (contract registration). According to the contract terms, the key or other events are invoked to trigger execution and complete the contract logic. It also provides functions for contract upgrades and cancellations. The operation monitoring module is mainly responsible for deployment, configuration modification, contract settings, cloud adaptation, and real-time status visualization output during product release, such as alarms, network monitoring, and monitoring of node device health status.

[0065] The platform's product service layer provides the basic capabilities and implementation frameworks for typical applications. Developers can leverage these basic capabilities, along with the specific characteristics of their business needs, to implement blockchain-based business logic. The application service layer provides blockchain-based application services to business stakeholders.

[0066] The following describes the application scenarios of the front-end page generation method provided in the embodiments of this application. Figure 3 A schematic diagram illustrating an application scenario according to an embodiment of this application is shown; Figure 4 A schematic diagram illustrating an application scenario according to another embodiment of this application is shown. Please refer to... Figure 3 and Figure 4 Although it is an application scenario of the present application embodiment, it is actually a front-end page generated based on the front-end page generation method provided in the present application embodiment.

[0067] Please see Figure 3To generate this front-end page, when executing the front-end page generation method, the user needs to create an entity corresponding to each piece of information. The entities to be created can include category entities and product entities. The category entities created by the user can be entities corresponding to category names such as communication, community, software, and games, while the product entities can be entities corresponding to product names such as Tencent QQ and QQ Mail. The elements configured by the user in the entity can be various specific information corresponding to the entity. For example, the elements configured in the group entity can be group attribute information, etc.

[0068] Please see Figure 4 This front-end page categorizes and displays information about various tools. To generate this page, a corresponding entity needs to be created for each tool and its category. For example, "Official Recommendations" is a category, requiring a corresponding entity; tools belonging to this category, such as Tencent Questionnaire and Tencent Index, also require corresponding entities. An entity for a tool may correspond to multiple different category entities, each at a different level. For instance, the lowest-level category for the tool "Train Head" is "Collection Tools," while its higher-level category is "Data Collection Tools." When generating this page, corresponding entities for both categories must be created.

[0069] pass Figure 3 and Figure 4 As can be seen, the solution in this application embodiment is particularly suitable for scenarios where page information has a hierarchical structure, the front-end display style is fixed, and the display content is determined by the back-end operators, such as portal websites and event operation pages.

[0070] The implementation details of the technical solutions in the embodiments of this application are described in detail below:

[0071] Figure 5 A flowchart illustrating a method for generating a front-end page according to an embodiment of this application is shown. This method can be executed by any device with communication and data processing capabilities, including local computer devices and cloud devices such as cloud servers or cloud server clusters. (Refer to...) Figure 5 As shown, the method for generating this front-end page includes at least the following steps:

[0072] In step 510, the entity corresponding to the obtained entity information is created.

[0073] All information, including entity information, can be configured by operators and then obtained by the execution terminal. Entity information can be the name of the entity.

[0074] Specifically, consider a webpage showcasing teachers who teach various subjects in a school. The operator enters "subject" and "teacher" into the management system, creating corresponding entities within the system. At this point, the operator becomes a user of the management system.

[0075] Users can configure various information, including entity information, using computer devices. The management system can be an application software located locally on the user's computer device, or it can be a system that the user needs to remotely access through a management backend client deployed on their computer device. The management system can reside locally on the terminal providing the entity information, or it can reside on a terminal device other than the terminal providing the entity information. That is, entity information can be obtained by the executing entity through directly receiving user input, or it can be obtained by the executing entity from other terminal devices, where the entity information is derived from user input.

[0076] Entity information can be entered by users such as operators, or it can be selected by users from the management system. In other words, entity information can be obtained by program modules.

[0077] An entity is an abstract thing represented in the form of data.

[0078] In step 520, elements are added to the entity according to the configured elements.

[0079] Elements are entities, and an entity can include one or more elements.

[0080] An element can be an attribute corresponding to an entity. An entity is actually an objectively existing and distinguishable thing; it is a collection of more elements.

[0081] For example, when using the management system, operators can add the "Name" element under the "Teaching Subject" entity; and add elements such as "Name", "Gender", "Avatar", and "Introduction" under the "Teacher" entity.

[0082] Figure 6 A flowchart illustrating the configuration-based construction of a front-end page according to an embodiment of this application is shown. Please refer to... Figure 6 As you can see, the front-end pages are built through configuration, primarily by enabling operations to manage the system. For example... Figure 6 As shown, the process of building the front-end page through configuration includes:

[0083] In step 610, an entity is created.

[0084] Figure 7 An embodiment according to this application is shown. Figure 6 A flowchart outlining the specific steps for creating an entity. Please refer to [link / reference]. Figure 7 The specific process of creating an entity includes the following steps:

[0085] In step 611, create an entity (entity name).

[0086] The operations team inputs the entity name into the management system to create the entity.

[0087] In step 612, the entity is saved to the database.

[0088] The management system saves the entities. Created entities must be saved for use in generating front-end pages.

[0089] In step 613, select an element.

[0090] The management system displays elements to the user, who then selects from the displayed elements and sends a selection command to the management system.

[0091] In step 614, add elements.

[0092] Users send an add command to the management system, notifying the system to add elements.

[0093] In step 615, elements are added to the entity.

[0094] The management system performs element addition operations, adding the elements to the corresponding entities.

[0095] Please continue reading. Figure 5 In step 530, the tree structure is configured according to the entity and the obtained entity relationship information corresponding to the entity, so that the tree nodes in the tree structure correspond to the entities, and the connection relationship of each tree node in the tree structure corresponds to the entity relationship information.

[0096] Specifically, the tree nodes in the tree structure are configured according to the entities, and the connection relationships between the tree nodes in the tree structure are configured according to the entity relationship information.

[0097] A tree structure, also known as a tree diagram, is a method of visually representing hierarchical structures, similar in form to the DOM (Document Object Model) tree. Its name comes from the symbolism of a tree representing the relationships between its components. Visually, it's an inverted tree, with the root node at the top (the beginning of the data) and the leaves at the bottom (the leaf nodes).

[0098] Therefore, tree structures can express things very well, such as Figure 3 and Figure 4 The diagram shows the hierarchical structure of the front-end page. The tree structure is the model of the front-end page to be generated, containing the main information of the page. Tree nodes are objects in the tree structure used to carry entity content.

[0099] When configuring tree nodes using entities, you can either add entities directly to the tree nodes or establish a mapping relationship between entities and tree nodes.

[0100] In actual program design, tree structures can take many forms, and correspondingly, tree nodes and their connections can also be diverse.

[0101] If entity relationship information reflects a hierarchical relationship between entities, then there will also be a corresponding hierarchical relationship between the tree nodes in the tree structure obtained through configuration.

[0102] For example, for a webpage that showcases the introductions of teachers who teach various subjects in a school, corresponding entities should be created for "teachers" and "subjects". The entity relationship information can be that there are multiple "teachers" under one "subject".

[0103] Figure 8 A schematic diagram of a tree structure according to an embodiment of this application is shown. Please refer to... Figure 8 As you can see, tree nodes in a tree structure include a parent node at a higher level and multiple child nodes branched from the parent node. This indicates that there are corresponding hierarchical relationships between entities, such as category affiliation.

[0104] Figure 9 A schematic diagram illustrating the relationship between entities and elements according to an embodiment of this application is shown. Figure 9 As you can see, entities are created based on their names, and each entity can include several elements, each of which is also created based on its name. The relationship between entities and elements is one-to-many. (Similar to...) Figure 4 As shown, when the constructed front-end page includes category entities and tool entities, the tool entities can exist in the form of display blocks. The aforementioned configuration entity relationship information is actually the process of adding category entities and display blocks to tree nodes according to their corresponding hierarchical relationships.

[0105] In step 540, based on the obtained content of the element, the content of the element is added to the tree node corresponding to the entity to which the element belongs in the tree structure to obtain tree configuration data.

[0106] As mentioned earlier, an element can be an attribute of an entity, and the content of an element can be its value or a set of values. Since elements belong to entities, their content can also be called the entity's content. Each entity corresponds to a tree node; therefore, the corresponding tree node can be found to add the element's content. Adding element content to a tree node is actually the process of attaching the element's content to the tree node object.

[0107] It can retrieve the content of multiple elements at once, and then add the content of each element to the corresponding tree node.

[0108] Figure 13 A flowchart illustrating the process of obtaining tree-structured configuration data according to one embodiment of this application is shown. Please refer to... Figure 13 The process of obtaining tree-structured configuration data may include the following steps:

[0109] In step 1310, once the content of an element is obtained, the element type corresponding to that element is determined.

[0110] Please continue reading Figure 9 As you can see, each entity contains elements of various types, including string elements, numeric elements, enumerated value elements, URL elements, monetary elements, and so on. The content of each element corresponds to its type.

[0111] In step 1320, the content of the element is validated according to the element type to determine whether the content of the element is valid.

[0112] As mentioned earlier, the content of an element is its value, and this step is actually a process of validating the validity of the element value.

[0113] exist Figure 9 In this context, some element types also have content restriction rules. For example, string elements are restricted by a maximum length, numeric elements by a range, and enumerated value elements by an enumeration range. These restriction rules can be used to validate the content of elements. For instance, the rule that a username cannot exceed five characters is a rule for validating the content of the element "username". Rules for validating the content of URL elements are used to check whether a URL is valid.

[0114] In step 1330, if the content of an element is valid, the content of the element is added to the tree node corresponding to the entity to which the element belongs in the tree structure to obtain tree configuration data.

[0115] The embodiments of this application implement the verification of the legality of the content of elements, which greatly reduces the possibility of defects in the final generated front-end page.

[0116] Please continue reading Figure 6 In step 620, tree nodes are configured according to entity relationships.

[0117] This step is actually a process of configuring the connection or hierarchical relationship between tree nodes based on entity relationship information.

[0118] In step 630, entity content is added to the tree node configuration.

[0119] Add the content of the elements and other entities to the corresponding tree nodes, and configure the tree nodes.

[0120] After adding content to elements in a tree structure, all the information in the tree structure can form tree-like configuration data.

[0121] Please continue reading. Figure 5 In step 550, a front-end page is generated based on the tree-structured configuration data.

[0122] The tree-structured configuration data contains the basic information used to generate the front-end page; therefore, the tree-structured configuration data can be used to generate the front-end page.

[0123] In one embodiment of this application, before generating the front-end page based on the tree configuration data, the method further includes: saving the tree configuration data to a tree configuration system; generating the front-end page based on the tree configuration data includes: generating the front-end page according to the tree configuration data obtained from the tree configuration system.

[0124] After saving the tree-structured configuration data to the tree configuration system, the tree configuration system can provide a configuration address; this address can be used to retrieve the tree-structured configuration data from the tree configuration system. In practical applications, the configuration address can be added to the front-end page; when the front-end page is accessed, it retrieves the tree-structured configuration data from the tree configuration system based on this configuration address, thereby enabling page loading.

[0125] Specifically, the management system mentioned above can be called a tree configuration system. Users can perform various configuration operations through interaction with the tree configuration system. The tree configuration system can be a local system located on the executing entity's local machine or a system located on a device outside the executing entity. For example, if the executing entity is a server hosting the tree configuration system, the tree configuration data generated on the server can be directly saved locally. If the executing entity is a computer device with a management backend client, and the tree configuration system is located on a server, then the executing entity can save the tree configuration data to the tree configuration system through interaction with the management backend client.

[0126] In one embodiment of this application, before generating the front-end page based on the tree-structured configuration data, the method further includes: exporting the tree-structured configuration data to obtain a configuration data file; generating the front-end page based on the configuration data includes: generating the front-end page based on the configuration data file.

[0127] Specifically, the executing entity can be a computer device equipped with a management backend client. Users can use the management backend client to export configuration data files to local storage space.

[0128] In this embodiment, the tree-structured configuration data is exported as a configuration data file, and the front-end page is directly built using the configuration data file. Therefore, this embodiment generates the front-end page based on static data, which greatly improves the performance of the generated front-end page.

[0129] Please continue reading Figure 6 In step 640, the configuration data is exported to the front-end page.

[0130] This step involves exporting the configuration data to obtain a configuration data file.

[0131] In step 650, the content is displayed.

[0132] The final generated page will load the configuration data and display it.

[0133] Figure 10 A flowchart illustrating the generation of a front-end page based on tree-structured configuration data according to an embodiment of this application is shown. Please refer to... Figure 10 This may include the following steps:

[0134] In step 1030, the target skin selected from the front-end skin library is obtained.

[0135] The front-end skin library includes multiple skins. Skins can include appearance information such as images and styles; for example, a card used to display information can be a skin.

[0136] The front-end skin library can reside locally on the executing entity, such as in the local storage space of a computer device. It can also be provided over a network; for example, a front-end skin library can be deployed on a server, and the user's terminal device can load skins from the library on the server. The user can then select a skin, and the server will receive the user's chosen skin.

[0137] In step 1040, tree-structured configuration data is loaded into the target skin to obtain the front-end page.

[0138] Loading the tree-structured configuration data into the target skin is the process of integrating the target skin and the tree-structured configuration data. The final front-end page is the page file obtained through data integration.

[0139] Figure 11 An embodiment according to this application is shown. Figure 10 A flowchart detailing the steps preceding step 1030 and steps 1030 themselves. Please refer to [link / reference]. Figure 11 It may also include the following steps:

[0140] In step 1010, skins that match the tree configuration data are determined from the front-end skin library and used as recommended skins.

[0141] Not all skins are compatible with a specific tree-structured configuration data. Using an incompatible skin can lead to a messy and stylistically incorrect front-end page. To generate a correctly styled and aesthetically pleasing front-end page, a matching skin must be used for the tree-structured configuration data.

[0142] Figure 12 A flowchart illustrating the determination of a recommended skin according to one embodiment of this application is shown. Please refer to... Figure 12 The process of determining recommended skins may include the following steps:

[0143] In step 1210, skins that match the width and depth of the tree structure are identified from the front-end skin library as candidate recommended skins.

[0144] The width of a tree structure can be the number of leaf nodes, which is equivalent to the number of product entities. The depth of a tree structure is the level of nesting between entities.

[0145] For example, if a skin fits a tree structure with a depth of 2, then that skin can be considered a candidate recommended skin when the depth of that tree structure is 2. Conversely, if a skin fits a tree structure with a depth between 3 and 10, then that skin cannot be selected as a candidate recommended skin when the depth of that tree structure is 2.

[0146] In step 1220, the skin that matches the element in the entity is determined from the candidate recommended skins and used as the recommended skin.

[0147] For example, a skin can be a card that introduces a character's information. This card can have several areas for adding attribute information, which can load various attribute information of the character accordingly.

[0148] Specifically, the skin can be abstracted as an internal display node that corresponds to a specific entity. The internal display node matches the entity based on the elements within the entity. For example, the teacher entity may include elements such as avatar, name, gender, and text description. The matching internal display node would be the one containing the avatar, name, gender, and text description.

[0149] In this embodiment, the system can intelligently recommend appropriate skins based on the content of the front-end page that the user wants to build, thereby improving the efficiency of front-end page generation and enhancing the user experience.

[0150] Please continue reading. Figure 11 In step 1020, a list of skins including recommended skins is pushed out.

[0151] You can add only recommended skins to the skin list, or you can add both recommended skins and other skins to the skin list at the same time. Recommended skins can be displayed at the top of the skin list.

[0152] In step 1030', the target skin selected from the skin list is obtained.

[0153] Users select skins from the list, thus issuing a selection command. The selection command can include the skin's identification information, thereby identifying the skin in the front-end skin library that corresponds to the skin's identification information as the user's target skin.

[0154] In one embodiment of this application, the method for generating the front-end page further includes: pushing recommended skins for users to select and fine-tune; and obtaining the fine-tuned recommended skin.

[0155] Specifically, after users obtain recommended skins using the management backend client, the management backend client interface can display a skin fine-tuning tool. Users can use the skin fine-tuning tool to adjust the style of the selected recommended skin, thereby providing a fine-tuned recommended skin.

[0156] In one embodiment of this application, the tree configuration system is used by multiple users and includes multiple tree configuration data. At least one tree configuration data in the tree configuration system is isolated or shared among the multiple users of the tree configuration system.

[0157] Specifically, the tree configuration system can be used by multiple product operations personnel, who can be for different products or businesses.

[0158] Isolating tree-structured configuration data among multiple users in a tree configuration system means restricting access to this data. Not all users can obtain this data; only a subset, or even a single, user, can access it. For example, access restrictions can be implemented in the tree configuration system so that only users responsible for the same product can access the tree-structured configuration data. It's easy to understand that when only one user can access the tree-structured configuration data, it is typically generated by that user.

[0159] The sharing of tree configuration data among multiple users in a tree configuration system means that multiple users or even all users of the tree configuration system can obtain the tree configuration data through the tree configuration system.

[0160] In one embodiment of this application, the tree configuration system also includes multiple entities created and multiple elements configured, wherein at least one entity and at least one element in the tree configuration system are isolated or shared among multiple users of the tree configuration system.

[0161] In one embodiment of this application, entities or elements in a tree configuration system are isolated or shared among multiple users of the tree configuration system.

[0162] Similar to the isolation and sharing of tree-structured configuration data among users, the isolation and sharing of entities and elements among users also restricts the sharing of data among users.

[0163] By sharing tree-structured configuration data, entities, and elements within the tree configuration system, the time users spend generating front-end pages can be further reduced, thus improving the efficiency of front-end page generation.

[0164] In one embodiment of this application, at least one of the tree configuration data, entities, and elements is shared in the tree configuration system through a paid subscription.

[0165] In other words, a user in the tree configuration system can upload tree-structured configuration data to the system, and other users need to pay to use this data. The user who uploaded the data can then earn revenue. This increases user incentive to upload tree-structured configuration data.

[0166] Figure 14 An architectural block diagram of a method for generating a front-end page according to an embodiment of this application is shown. Please refer to... Figure 14As shown in the diagram, the architecture includes a tree configuration system, a front-end skin library, and multiple management backends. One or more of the tree configuration system, front-end skin library, and management backends can be deployed on a single terminal device, or they can be deployed on multiple terminal devices. Each management backend can be used by an operations staff member. Each management backend can interact with the tree configuration system and the front-end skin library to execute the front-end page generation method provided in this application embodiment. Specifically, the tree configuration system and the front-end skin library can reside on the same server, which can serve as the execution entity in this application embodiment; each management backend can reside on a terminal device (such as a computer device) capable of communicating with the server.

[0167] Figure 15 A schematic diagram illustrating the architectural principle of a front-end page generation method according to an embodiment of this application is shown.

[0168] Please see Figure 15 Each management backend is used by a corresponding tenant. For example, management backend A is used by tenant A, management backend B is used by tenant B, and so on. Each tenant can be an operations staff member for a product. The tree configuration system includes multi-tenant entities, shared entities, and an element library. Multi-tenant entities are entities used in isolation between tenants and can only be used by specific tenants. Shared entities are entities that can be used by all tenants. The element library is a collection of elements configured by each tenant and can be shared among all tenants.

[0169] use Figure 15 The process of generating a front-end page using the architecture shown can be as follows: The tenant interacts with the tree configuration system using its management backend, configures the tree structure according to the entities and elements in the tree configuration system, and can also configure custom entities and / or elements in the tree configuration system to obtain tree configuration data; then, the tree configuration data is integrated with the skins in the skin library to obtain the generated front-end page.

[0170] Figure 16 A flowchart illustrating the overall process of constructing a front-end page through configuration according to an embodiment of this application is shown. See also... Figure 16 This may include the following steps:

[0171] In step 1610, the front-end development team implements the page style.

[0172] Front-end developers can create skins to represent page styles.

[0173] In step 1620, the operator configures the entity.

[0174] Operators can perform operations such as creating entities and configuring elements within entities.

[0175] In step 1630, the operator configures the tree nodes.

[0176] Operators can add the content of elements to tree nodes and configure the connection relationships and hierarchical relationships between tree nodes.

[0177] In step 1640, the operations personnel export the configuration.

[0178] Operators can export the tree-structured configuration data to a file.

[0179] In step 1650, the front-end page loads the configuration.

[0180] The skin loads the configuration file, resulting in the final front-end page.

[0181] In summary, according to the front-end page generation method provided in this application embodiment, when building the front-end page, relevant personnel only need to first create the various entities required for the page in the system, configure the elements contained in the entities, then provide entity relationship information, and use the entities and entity relationship information to configure the tree structure containing tree nodes. Next, the content of the elements is provided to further configure the corresponding tree nodes. Therefore, the entire front-end page generation process is basically achieved through user configuration, involving almost no code writing or debugging. While allowing flexible customization of the front-end page configuration, it greatly reduces the development cost of front-end projects and significantly improves the development efficiency of front-end projects. Furthermore, this application embodiment addresses the common scenario in most projects where the front-end style is fixed and the content is controlled by operations personnel. It can reduce the cost of back-end development and, to a certain extent, reduce the integration and debugging costs for front-end developers. In addition, this application embodiment can also export the tree configuration data as a file and use it to build the front-end page, realizing the staticization of the front-end page and greatly improving the performance of front-end page access.

[0182] The following describes an apparatus embodiment of this application, which can be used to execute the front-end page generation method in the above embodiments of this application. For details not disclosed in the apparatus embodiments of this application, please refer to the embodiments of the front-end page generation method described above.

[0183] Figure 17 A block diagram of a front-end page generation apparatus according to an embodiment of this application is shown.

[0184] Reference Figure 17 As shown, a front-end page generation apparatus 1700 according to an embodiment of this application includes: a creation unit 1710, a first adding unit 1720, a configuration unit 1730, a second adding unit 1740, and a generation unit 1750.

[0185] The creation unit 1710 is used to create an entity corresponding to the obtained entity information; the first adding unit 1720 is used to add the configured element to the entity, wherein the element belongs to the entity; the configuration unit 1730 is used to configure the tree structure according to the entity and the obtained entity relationship information corresponding to the entity, so that the tree nodes in the tree structure correspond to the entity, and the connection relationship of each tree node in the tree structure corresponds to the entity relationship information; the second adding unit 1740 is used to add the content of the obtained element to the tree node corresponding to the entity to which the element belongs in the tree structure, thereby obtaining tree configuration data; and the generation unit 1750 is used to generate a front-end page based on the tree configuration data.

[0186] In some embodiments of this application, based on the foregoing scheme, the generation unit 1750 is configured to: obtain a target skin selected from a front-end skin library, the front-end skin library including multiple skins; load the tree configuration data into the target skin to obtain the front-end page.

[0187] In some embodiments of this application, based on the foregoing scheme, before obtaining the target skin selected from the front-end skin library, the generation unit 1750 is further configured to: determine the skin that matches the tree configuration data from the front-end skin library as a recommended skin; push a skin list including the recommended skin; the generation unit 1750 is configured to: obtain the target skin selected from the skin list.

[0188] In some embodiments of this application, based on the foregoing scheme, the generation unit 1750 is configured to: determine from the front-end skin library a skin that matches the width and depth of the tree structure as a candidate recommended skin; and determine from the candidate recommended skin a skin that matches an element in the entity as a recommended skin.

[0189] In some embodiments of this application, based on the foregoing scheme, before generating the front-end page based on the tree configuration data, the second adding unit 1740 is further configured to: save the tree configuration data to the tree configuration system; the generating unit 1750 is configured to: generate the front-end page according to the tree configuration data obtained from the tree configuration system.

[0190] In some embodiments of this application, based on the foregoing scheme, the tree configuration system is used by multiple users, the tree configuration system includes multiple tree configuration data, and at least one of the tree configuration data in the tree configuration system is isolated or shared among the multiple users of the tree configuration system.

[0191] In some embodiments of this application, based on the foregoing scheme, the tree configuration system further includes multiple entities created and multiple elements configured, and at least one entity and at least one element in the tree configuration system are isolated or shared among multiple users of the tree configuration system.

[0192] In some embodiments of this application, based on the foregoing scheme, before generating the front-end page based on the tree configuration data, the second adding unit 1740 is further configured to: perform an export operation on the tree configuration data to obtain a configuration data file; the generating unit 1750 is configured to: generate the front-end page based on the configuration data file.

[0193] In some embodiments of this application, based on the aforementioned scheme, the second adding unit 1740 is configured to: when the content of an element is obtained, determine the element type corresponding to the element; verify the content of the element according to the element type to determine whether the content of the element is valid; if the content of the element is valid, add the content of the element to the tree node corresponding to the entity to which the element belongs in the tree structure to obtain tree configuration data.

[0194] Figure 18 A schematic diagram of the structure of a computer system suitable for implementing the electronic device of the present application is shown.

[0195] It should be noted that, Figure 18 The computer system 1800 of the electronic device shown is merely an example and should not impose any limitation on the functionality and scope of use of the embodiments of this application.

[0196] like Figure 18 As shown, the computer system 1800 includes a Central Processing Unit (CPU) 1801, which can perform various appropriate actions and processes based on programs stored in Read-Only Memory (ROM) 1802 or programs loaded from storage portion 1808 into Random Access Memory (RAM) 1803, such as performing the methods described in the above embodiments. Various programs and data required for system operation are also stored in RAM 1803. The CPU 1801, ROM 1802, and RAM 1803 are interconnected via bus 1804. An input / output (I / O) interface 1805 is also connected to bus 1804.

[0197] The following components are connected to I / O interface 1805: an input section 1806 including a keyboard, mouse, etc.; an output section 1807 including a cathode ray tube (CRT), liquid crystal display (LCD), etc., and speakers, etc.; a storage section 1808 including a hard disk, etc.; and a communication section 1809 including a network interface card such as a LAN (Local Area Network) card, modem, etc. The communication section 1809 performs communication processing via a network such as the Internet. A drive 1810 is also connected to I / O interface 1805 as needed. Removable media 1811, such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc., are installed on drive 1810 as needed so that computer programs read from them can be installed into storage section 1808 as needed.

[0198] Specifically, according to embodiments of this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via communication section 1809, and / or installed from removable medium 1811. When the computer program is executed by central processing unit (CPU) 1801, it performs various functions defined in the system of this application.

[0199] It should be noted that the computer-readable medium shown in the embodiments of this application can be a computer-readable signal medium, a computer-readable storage medium, or any combination of the two. A computer-readable storage medium can be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM), flash memory, optical fiber, portable compact disc read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In this application, a computer-readable storage medium can be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In this application, a computer-readable signal medium can include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such transmitted data signals can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. The computer-readable signal medium can also be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The program code contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to wireless, wired, etc., or any suitable combination thereof.

[0200] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. Each block in a flowchart or block diagram may represent a module, segment, or portion of code, which contains one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in a block diagram or flowchart, and combinations of blocks in a block diagram or flowchart, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0201] The units described in the embodiments of this application can be implemented in software or hardware, and the described units can also be located in a processor. The names of these units do not necessarily limit the specific unit itself.

[0202] In one aspect, this application also provides a computer-readable medium, which may be included in the electronic device described in the above embodiments; or it may exist independently and not assembled 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 perform the methods described in the above embodiments.

[0203] It should be noted that although several modules or units for the device used to perform actions have been mentioned in the detailed description above, this division is not mandatory. In fact, according to the embodiments of this application, the features and functions of two or more modules or units described above can be embodied in one module or unit. Conversely, the features and functions of one module or unit described above can be further divided and embodied by multiple modules or units.

[0204] Through the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein can be implemented by software or by combining software with necessary hardware. Therefore, the technical solutions according to the embodiments of this application can be embodied in the form of a software product, which can be stored in a non-volatile storage medium (such as a CD-ROM, USB flash drive, external hard drive, etc.) or on a network, including several instructions to cause a computing device (such as a personal computer, server, touch terminal, or network device, etc.) to execute the methods according to the embodiments of this application.

[0205] Other embodiments of this application will readily occur to those skilled in the art upon consideration of the specification and practice of the embodiments disclosed herein. This application is intended to cover any variations, uses, or adaptations of this application that follow the general principles of this application and include common knowledge or customary techniques in the art not disclosed herein.

[0206] The data collection and processing plan outlined in this application must be implemented in strict accordance with the requirements of relevant national laws and regulations, obtaining the informed consent or separate consent of the data subject (or having a legal basis as stipulated by the relevant national laws and regulations), and conducting subsequent data use and processing within the scope authorized by laws and regulations and the data subject.

[0207] It should be understood that this application is not limited to the precise structure described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. The scope of this application is limited only by the appended claims.

Claims

1. A method for generating a front-end page, characterized in that, The method includes: Based on the obtained entity information configured by the user, create the entity corresponding to the entity information and save the entity to the database; Based on user-configured elements, the electronic device adds the elements to the entity, and the elements belong to the entity; Based on the entity and the obtained entity relationship information corresponding to the entity, the tree structure is configured so that the tree nodes in the tree structure correspond to the entity, and the connection relationship of each tree node in the tree structure corresponds to the entity relationship information, wherein the entity relationship information includes category attribution relationship; Based on the obtained element value of the element, the element value of the element is added to the tree node corresponding to the entity to which the element belongs in the tree structure to obtain tree configuration data; The tree configuration data is saved to the tree configuration system; the tree configuration system is used by multiple users, and includes multiple tree configuration data. At least one of the tree configuration data in the tree configuration system is isolated or shared among the multiple users of the tree configuration system; the tree configuration system also includes multiple created entities and multiple configured elements, and at least one entity and at least one element in the tree configuration system are isolated or shared among the multiple users of the tree configuration system. Generate a front-end page based on the tree configuration data; the generation of the front-end page based on the tree configuration data includes: generating a front-end page according to the tree configuration data obtained from the tree configuration system.

2. The method for generating a front-end page according to claim 1, characterized in that, The generation of the front-end page based on the tree-structured configuration data includes: Obtain the target skin selected from the front-end skin library, which includes multiple skins; The tree-structured configuration data is loaded into the target skin to obtain the front-end page.

3. The method for generating a front-end page according to claim 2, characterized in that, Before obtaining the target skin selected from the front-end skin library, the method further includes: Skins that match the tree-structured configuration data are determined from the front-end skin library and used as recommended skins; The push notification includes a list of skins that include the recommended skins; The step of obtaining the target skin selected from the front-end skin library includes: Retrieve the target skin selected from the skin list.

4. The method for generating a front-end page according to claim 3, characterized in that, The step of determining a skin from the front-end skin library that matches the tree-structured configuration data as a recommended skin includes: Skins that match the width and depth of the tree structure are identified from the front-end skin library and used as candidate recommended skins. The skin that matches the element in the entity is selected from the candidate recommended skins and used as the recommended skin.

5. The method for generating a front-end page according to claim 1, characterized in that, Before generating the front-end page based on the tree-structured configuration data, the method further includes: The tree-structured configuration data is exported to obtain a configuration data file; The process of generating a front-end page based on the configuration data includes: The front-end page is generated based on the configuration data file.

6. The method for generating a front-end page according to claim 1, characterized in that, The step of adding the obtained element value of the element to the corresponding tree node of the entity to which the element belongs in the tree structure to obtain tree configuration data includes: Once the element value of an element is obtained, determine the element type corresponding to that element; The element value of the element is validated according to the element type to determine whether the element value is valid. If the element value is valid, the element value is added to the tree node corresponding to the entity to which the element belongs in the tree structure to obtain tree configuration data.

7. A front-end page generation device, characterized in that, Its features are, The device includes: A creation unit is used to create an entity corresponding to the entity information based on the obtained entity information configured by the user, and save the entity to the database; The first adding unit is used to add the element to the entity according to the element configured by the user, wherein the element belongs to the entity; A configuration unit is configured to configure a tree structure according to the entity and the obtained entity relationship information corresponding to the entity, so that the tree nodes in the tree structure correspond to the entity, and the connection relationship of each tree node in the tree structure corresponds to the entity relationship information, wherein the entity relationship information includes category attribution relationship; The second adding unit is used to add the element value of the obtained element to the tree node corresponding to the entity to which the element belongs in the tree structure, thereby obtaining tree configuration data; and to save the tree configuration data to the tree configuration system; the tree configuration system is used by multiple users, and includes multiple tree configuration data, at least one of the tree configuration data in the tree configuration system is isolated or shared among the multiple users of the tree configuration system; the tree configuration system also includes multiple created entities and multiple configured elements, at least one entity and at least one element in the tree configuration system are isolated or shared among the multiple users of the tree configuration system; A generation unit is configured to generate a front-end page based on the tree configuration data; the generation unit is configured to generate a front-end page based on the tree configuration data obtained from the tree configuration system.

8. A computer-readable medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the method for generating a front-end page as described in any one of claims 1 to 6.

9. An electronic device, characterized in that, include: One or more processors; A storage device for storing one or more programs, which, when executed by one or more processors, cause the one or more processors to implement the method for generating a front-end page as described in any one of claims 1 to 6.

Images