CN111666074B - A method, related device and system for customizing web applications - Google Patents
A method, related device and system for customizing web applications Download PDFInfo
- Publication number
- CN111666074B CN111666074B CN201910165259.4A CN201910165259A CN111666074B CN 111666074 B CN111666074 B CN 111666074B CN 201910165259 A CN201910165259 A CN 201910165259A CN 111666074 B CN111666074 B CN 111666074B
- Authority
- CN
- China
- Prior art keywords
- file
- web application
- logic
- custom
- customization
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/36—Software reuse
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/65—Updates
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Human Computer Interaction (AREA)
- Stored Programmes (AREA)
Abstract
The embodiment of the application discloses a method, a related device and a system for customizing web applications. In the method, a custom UI instruction file is used for describing how to customize a user interface of a base line version, and the base line UI file is preprocessed according to the custom UI instruction file to generate a custom UI file, so that customization of user interface display is realized; and an object-oriented class inheritance method is adopted, and the customization of logic processing is realized by dynamically loading the interactive logic file and the customized logic file. The method enables the web front-end interface to be placed in the base line version, and improves the efficiency of web application development. And the separation of the base line and the customization is realized, so that the smooth upgrading of the customization version can be realized when the base line version is upgraded, and the customization cost of web application development is reduced.
Description
Technical Field
The present disclosure relates to the field of computer technologies, and in particular, to a method, related device, and system for customizing a web application.
Background
With the development of web page (web) applications, the customization needs of different customers for web applications are also diverse. The web application version facing the common requirements of all clients may be referred to as a baseline version, and the application version modified from the baseline version according to the requirements of different clients may be referred to as a custom version.
Currently, in web application development, the baseline version only provides a constant framework and services, such as providing a generic platform, components and tools, while the functionality that is potentially customized is developed in accordance with the customized version. Because the front-end interface of the web application has a lot of customization requirements and is difficult to predict, the baseline version does not contain the characteristics related to interface display and interface interaction logic, so that similar requirements of different clients are required to be repeatedly developed, and the customization cost of the web application is high.
Disclosure of Invention
The embodiment of the application provides a web application customization method, a related device and a system, which can avoid the repeated development of similar requirements of a web application front-end interface in different customization versions and reduce the customization cost of web application development.
In a first aspect, embodiments of the present application provide a method for customizing a web application, the method comprising:
the Web application client loads a customized User Interface (UI) file corresponding to the Web application identifier, wherein the customized UI file is used for describing a user interface display of a customized version; continuing to load an interaction logic file, wherein the interaction logic file corresponds to the customized UI file, and is used for describing logic processing of a user interface with a base line version, such as how to respond to clicking of the user on the interface, how to perform page skip and the like; the customization of the interactive logic is realized by adopting an object-oriented class inheritance method, firstly, the customization logic subclass corresponding to the baseline logic parent class in the interactive logic file is determined, whether the interactive logic of the baseline version needs to be customized and expanded is generally determined by searching whether the baseline logic parent class is contained in the configuration file, and if so, the corresponding customization logic subclass is determined. And then, loading a custom logic file corresponding to the custom logic subclass, and instantiating the custom logic subclass, so that a handle pointing to the base line logic parent class in the interactive logic file is changed to point to the custom logic subclass. The base line logic parent class is a base line class object in the interaction logic file, describes the method and attribute of the interaction logic of the base line version, the custom logic subclass is a subclass object expanded in a class inheritance mode, and further describes the method and attribute of the interaction logic needed to be customized in the custom version on the basis of inheritance of all the methods and attributes of the base line logic parent class.
The method realizes the customization of the user interface display by loading the customization UI file, adopts an object-oriented class inheritance method, and realizes the customization of the interface logic processing by dynamically loading the interaction logic file and the customization logic file. The method realizes customization of the web application front-end interface, so that the web application front-end interface can be put into the web baseline version, similar requirements of the front-end interface are prevented from being repeatedly developed in customized versions of different clients, and the development efficiency of the web application is improved.
In one possible solution, the custom UI file is formed by preprocessing a baseline UI file according to a custom UI instruction in the custom UI instruction file, and is completed by a custom preprocessing device. The customized preprocessing equipment can be a web application client or a web application development terminal.
The method enables separation of baseline and customization in web application user interface customization. When the base line version is upgraded, the upgraded base line UI file is preprocessed according to the customized UI instruction file, so that synchronous upgrading of the customized version can be realized, and the customization cost of web application development is reduced.
In one possible scheme, the method for preprocessing the baseline UI file specifically includes:
The customized preprocessing equipment searches nodes with the same node identifiers as anchor points in the customized UI instructions in the baseline UI file; and skipping to corresponding processing logic according to the instruction name of the customization UI instruction, and performing customization processing on the node.
According to the method, the node needing customization processing can be accurately positioned according to the anchor point in the customization UI instruction, and corresponding customization modification is carried out on the baseline UI file. The method realizes customization of the user interface of the web application, realizes non-invasive customization, and ensures that smooth upgrading of the customized version can be realized when the baseline version is upgraded.
In one possible solution, before the web application client loads the customized UI file corresponding to the web application identifier, the method further includes:
the web application client sends a request message to a server, wherein the request message comprises the web application identifier; and receiving the corresponding customized UI file returned by the server, wherein the customized UI file is formed by preprocessing the baseline UI file by the web application development end and is uploaded to the server. In this scenario, the custom preprocessing device is a web application developer.
In the method, the web application development end preprocesses the baseline UI file to generate the customized UI file, and uploads the customized UI file to the server, thereby realizing customization of the user interface of the web application.
In one possible solution, before the web application client loads the customized UI file corresponding to the web application identifier, the method further includes:
the web application client sends a request message to the server, wherein the request message comprises the web application identifier; receiving a corresponding baseline UI file returned by the server; loading a customized UI instruction file corresponding to the baseline UI file; and preprocessing the baseline UI file according to the custom UI instructions in the custom UI instruction file to form the custom UI file. In this scenario, the custom preprocessing device is a web application client.
In the method, the web application client side preprocesses the baseline UI file to generate the customized UI file, so that in the adjustment and measurement stage of the web application program, a developer can modify the customized UI instruction file at the web application client side, the developer can observe the change effect of the user interface in real time, and the development of the customization of the web application is more convenient and flexible.
In a second aspect, embodiments of the present application provide a web application client, including:
the loading module is used for loading the customized User Interface (UI) file corresponding to the web application identifier; the loading module is further used for loading an interaction logic file, and the interaction logic file corresponds to the customized UI file; the determining module is used for determining a customized logic subclass corresponding to a baseline logic parent class in the interaction logic file, wherein the customized logic subclass inherits the method and the attribute of the baseline logic parent class; the loading module is further configured to load a custom logic file corresponding to the custom logic subclass.
The method realizes the customization of the user interface display by loading the customization UI file, adopts an object-oriented class inheritance method, and realizes the customization of the interface logic processing by dynamically loading the interaction logic file and the customization logic file. The method realizes customization of the web application front-end interface, so that the web application front-end interface can be put into the web baseline version, similar requirements of the front-end interface are prevented from being repeatedly developed in customized versions of different clients, and the development efficiency of the web application is improved.
In one possible approach, the custom UI file is formed by a custom preprocessing device preprocessing the baseline UI file, the preprocessing being based on custom UI instructions in a custom UI instruction file. The customized preprocessing equipment can be a web application client or a web application development terminal.
The method enables separation of baseline and customization in web application user interface customization. When the base line version is upgraded, the upgraded base line UI file is preprocessed according to the customized UI instruction file, so that synchronous upgrading of the customized version can be realized, and the customization cost of web application development is reduced.
In one possible solution, before the loading module is configured to load the corresponding custom UI file, the method further includes: a sending module, configured to send a request message to the server, where the request message includes the web application identifier; the receiving module is used for receiving a baseline UI file corresponding to the web application identifier returned by the server; the loading module is further used for loading a customized UI instruction file corresponding to the baseline UI file; and the preprocessing module is used for preprocessing the baseline UI file according to the custom UI instruction in the custom UI instruction file to form the custom UI file. In this scenario, the custom preprocessing device is a web application client.
In the method, the web application client side preprocesses the baseline UI file to generate the customized UI file, so that in the adjustment and measurement stage of the web application program, a developer can modify the customized UI instruction file at the web application client side, the developer can observe the change effect of the user interface in real time, and the development of the customization of the web application is more convenient and flexible.
In one possible solution, the preprocessing module is configured to preprocess the baseline UI file according to the customization UI instruction to form the customization UI file, and specifically includes: a determining sub-module, configured to determine, according to an anchor point of the custom UI instruction, a corresponding node in the baseline UI file, where the determining is based on an identifier of the node being the same as the anchor point; and the customization processing sub-module is used for jumping to corresponding processing logic according to the instruction name of the customization UI instruction and carrying out customization processing on the node.
According to the method, the node needing customization processing can be accurately positioned according to the anchor point in the customization UI instruction, and corresponding customization modification is carried out on the baseline UI file. The method realizes customization of the user interface of the web application, realizes non-invasive customization, and ensures that smooth upgrading of the customized version can be realized when the baseline version is upgraded.
In a third aspect, embodiments of the present application provide a web application client, including:
the system comprises a processor, a memory, a transceiver and a bus, wherein the processor, the memory and the transceiver are connected through the bus, the transceiver is used for receiving and sending messages, the memory is used for storing a set of program codes, and the processor is used for calling the program codes stored in the memory and executing the steps according to the first aspect or any scheme of the first aspect of the embodiment of the application.
The technical effects caused by any one of the solutions in the third aspect may be referred to technical effects caused by different solutions in the first aspect, which are not described herein.
In a fourth aspect, embodiments of the present application further provide a system for customizing a web application, including a web application development terminal, a server, and a web application client terminal: the web application development end is used for preprocessing the base line UI file according to the custom UI instruction file to form a custom UI file, and sending the custom UI file to the server. This is done in the web application development phase; in the call web application phase or the use web application phase: the web application client is used for acquiring the customized UI file from the server according to the web application identifier and loading the customized UI file; the web application client is used for loading an interaction logic file, and the interaction logic file corresponds to the customized UI file; the web application client is used for determining a customized logic subclass corresponding to a baseline logic parent class in the interaction logic file, and the customized logic subclass inherits the method and the attribute of the baseline logic parent class; the web application client is used for loading the customized logic file corresponding to the customized logic subclass.
The method realizes the customization of user interface display by preprocessing the base line UI file to generate a customization UI file, and realizes the customization of interface logic processing by dynamically loading an interaction logic file and a customization logic file by adopting an object-oriented class inheritance method. The method realizes customization of the web application front-end interface, so that the web application front-end interface can be put into the web baseline version, similar requirements of the front-end interface are prevented from being repeatedly developed in customized versions of different clients, and the development efficiency of the web application is improved. And, the method achieves a separation of baseline and customization in web application customization. When the base line version is upgraded, the upgraded base line UI file is preprocessed according to the customized UI instruction file, and the upgraded interactive logic file and the customized logic file are dynamically loaded to realize synchronous upgrading of the customized version, so that the customization cost of web application development is reduced.
In one possible solution, the web application development end is configured to pre-process the baseline UI file according to the custom UI instruction file to form the custom UI file, and specifically includes: the web application development end is used for determining corresponding nodes in the baseline UI file according to the anchor points of the customized UI instructions, and the determination is based on the fact that identifiers of the nodes are identical to the anchor points; and skipping to corresponding processing logic according to the instruction name of the customization UI instruction, and performing customization processing on the node.
According to the method, the node needing customization processing can be accurately positioned according to the anchor point in the customization UI instruction, and corresponding customization modification is carried out on the baseline UI file. The method realizes customization of the user interface of the web application, realizes non-invasive customization, and ensures that smooth upgrading of the customized version can be realized when the baseline version is upgraded.
In a fifth aspect, embodiments of the present application also provide a computer readable storage medium comprising a set of program codes for performing the method according to any implementation of the first aspect of the embodiments of the present application.
These and other aspects of the present application will be more readily apparent from the following description of the embodiments.
Drawings
Fig. 1 is a schematic diagram of a system architecture according to an embodiment of the present application;
FIG. 2 is a flow chart of a method for customizing a web application according to an embodiment of the present application;
FIG. 3 is a flowchart illustrating a method for preprocessing a custom UI file according to an embodiment of the present disclosure;
FIG. 4 is a flow chart of another method for web application customization provided by embodiments of the present application;
fig. 5 is a schematic diagram of a composition of a web application client according to an embodiment of the present application;
FIG. 6 is another schematic diagram of a web application client according to an embodiment of the present application;
fig. 7 is a schematic diagram of a composition of a web application customization system according to an embodiment of the present application.
Detailed Description
The embodiment of the application provides a web application customization method, a related device and a system, which are used for solving the problem that similar requirements of a web application front-end interface in the prior art are repeatedly developed in different customization versions.
Please refer to fig. 1, which is a schematic diagram of a system architecture provided in an embodiment of the present application. In a typical application scenario, web application clients, servers, and web application development ends are included.
A Web application client is an application running on a client to access Web services, which may be a piece of software that can access Web services, or a program or plug-in running in a browser, including but not limited to a computer, a handheld or laptop device, a mobile device (such as a mobile phone, a tablet, a personal digital assistant), and so forth.
In this embodiment, the web application client may load a custom User Interface (UI) file corresponding to the web application identifier, so as to implement customization of user interface presentation; the web application client can load the interaction logic file and realize customization of the interaction logic by an object-oriented class inheritance method. Alternatively, the web application client may obtain the baseline UI file from the server and pre-process the baseline UI file according to the UI instructions in the custom UI instruction file to form the custom UI file. In this case, the baseline UI file is preprocessed by a web application client, which may be referred to as a custom preprocessing device. Alternatively, the web application client may obtain the custom UI file directly from the server.
A server is a program that provides services for web application clients and may run on a computer. In this embodiment, the server may store the file uploaded by the web application development end, may process the request of the web application client, and returns the requested file to the web application client.
The Web application development end is a program running on the development end to develop Web applications, and can run on a computer. In this embodiment, the web application development terminal may upload the web application-related file to the server. Alternatively, the web application developer may upload the baseline UI file, the custom UI instruction file, the interaction logic file, and the custom logic file to the server. Optionally, the web application development end may preprocess the baseline UI file according to the customization UI instruction in the customization UI instruction file to form a customization UI file, and then upload the customization UI file, the interaction logic file and the customization logic file to the server. In this case, the baseline UI file is preprocessed by the web application developer, which may be referred to as a custom preprocessing device.
Referring to fig. 2, a flowchart of a method for customizing a web application according to an embodiment of the present application is shown. The Web application client acquires the customized UI file, the interactive logic file and the customized logic file from the server, loads the customized UI file to realize the customization of interface display, dynamically loads the interactive logic file and the customized logic file, and adopts an object-oriented class inheritance method to realize the customization of interface logic processing. The method comprises the following steps:
A Web application client sends a request message to the server, wherein the request message comprises the web application identifier;
the Web application client requests the corresponding Web file from the server according to the Web application identifier. The web application identifier is a unique identifier that identifies a web application, and may be a uniform resource locator (uniform resource locator, URL).
202. And the server returns the customized UI file corresponding to the web application identifier.
The server receives the request message sent by the web application client and returns the corresponding customized UI file according to the web application identifier. The customized UI file is formed by preprocessing the baseline UI file by the web application development end and is uploaded to the server, and the specific method is shown in the embodiment of the method described with reference to FIG. 3. The baseline UI file is a file that faces all clients' similar needs for the user interface UI. The customized UI file is a UI file after the base line UI file is correspondingly modified according to different requirements of different clients. In this case, the web application development end may be referred to as a custom preprocessing device. It should be noted that the baseline UI file and the custom UI file are used to describe the user interface presentation.
And 203, loading the customized UI file by the Web application client.
And the Web application client receives the customized UI file and analyzes the customized UI file. It should be noted that, in the embodiment of the present application, the "loading" of the file may be analyzing the file, or may be acquiring the file from the memory and analyzing the file, or may be acquiring the file from another device and then analyzing the file, which is not limited in the present application.
A web application client loads an interaction logic file, the interaction logic file corresponding to the custom UI file.
The interactive logic file is used to describe the logic processing of the user interface, such as how to respond to a user click on the interface, how to make a page jump, etc. The interactive logic file is written in a programming language that the browser can recognize to run, such as Javascript (JS) file, VBScript (VBS) file.
Optionally, the custom UI file contains a corresponding interaction logic file, and thus, in step 203, the web application client receives the custom UI file and also receives the corresponding interaction logic file. Optionally, the running framework of the web application client includes a reference rule, for example, the file name of the corresponding interaction logic file is the same as the file name of the customized UI file. The Web application client obtains the corresponding interaction logic file according to the reference rule, for example, the request message can be sent again to the server to obtain the interaction logic file, or the interaction logic file is searched locally.
And the Web application client determines a custom logic subclass corresponding to the baseline logic parent class in the interaction logic file, and the custom logic subclass inherits the method and the attribute of the baseline logic parent class.
The embodiment adopts an object-oriented mode to design the interaction logic, and the interaction logic of the baseline version is customized and expanded through class inheritance. The interactive logic file is a file facing all clients' similar demands on the interactive logic, and is an interactive logic file of a baseline version.
The Web application client may query the configuration file to determine if the interaction logic file requires custom extensions. For example, the web application client queries whether the configuration file contains the baseline logic parent class in the interaction logic file, and if so, can determine the custom logic subclass corresponding to the baseline logic parent class.
The base line logic parent class is a base line class object in the interaction logic file, describes a method and an attribute of interface logic processing of a base line version, the custom logic subclass is a subclass object expanded in a class inheritance mode, and further describes a method and an attribute of interface logic processing required to be custom in a custom version on the basis of inheriting all the methods and the attributes of the base line logic parent class.
And the Web application client loads the customized logic file corresponding to the customized logic subclass.
And the Web application client acquires the customized logic file corresponding to the customized logic subclass. Optionally, the custom logic file corresponding to the interactive logic file may be sent to the web application client together with the custom UI file and the interactive logic file, that is, in step 203, the web application client receives the custom logic file sent by the server; alternatively, the custom logic file corresponding to the interactive logic file may be sent to the web application client together with the interactive logic file, that is, in step 204, the web application client receives the custom logic file sent by the server; optionally, after determining the custom logic subclass in step 205, the web application client requests the corresponding custom logic file from the server and receives the custom logic file returned by the server. The corresponding relationship between the custom logic subclass and the custom logic file may be obtained by querying the configuration file, or may be obtained by obtaining the file name of the custom logic file, for example, the file name of the custom logic file is set as the name of the custom logic subclass.
And the Web application client loads the customized logic file, instantiates the customized logic subclass, and the handle in the interaction logic file, which points to the baseline logic parent class, points to the customized logic subclass after the instantiation is completed, so that the original binding access with the baseline logic parent class in the customized UI file is also switched to the binding access with the customized logic subclass. In this embodiment, the custom logic subclass includes all methods and attributes of the baseline logic parent class, so that normal operation of the business of the original baseline version is not affected, and instantiation of the custom logic subclass changes the behavior of the baseline logic parent class, and custom of the interaction logic is realized.
It should be noted that the interface of the custom UI file representation may contain sub-components, which are also combinations of custom UI files and interaction logic files. The Web application may determine whether the current interface includes a sub-component, and when the interface represented by the customized UI file further includes a sub-component, traverse the uniform location identifier of the sub-component, and load the sub-component in a recursive call manner, where the specific operation process is the same as steps 203-206, and will not be described herein again. When all the custom UI files, interaction logic files and custom logic files (including sub-components) required for the web application to run are loaded, the web application enters a functional running phase, and a running effect of 'baseline + custom' is exhibited.
It should be understood that, in the embodiments of the present application, the naming of the baseline UI file, the custom UI file, the interaction logic file, the baseline logic parent class, the custom logic subclass, and the like is an example name that is taken for clarity of explanation of the technical solution, and is not meant to limit the embodiments of the present application.
In the method for customizing the web application, which is provided by the embodiment of the application, customization of user interface display is realized by loading the customization UI file, wherein the customization UI file is formed by preprocessing a baseline UI file by customization preprocessing equipment. Meanwhile, the embodiment of the application adopts an object-oriented class inheritance method, and realizes the customization of interface logic processing by dynamically loading the interaction logic file and the customization logic file. When the web version is upgraded, only the baseline UI file and the interaction logic file are required to be upgraded. The method enables the front-end interface of the web application to be placed in the web baseline version, avoids the repeated development of similar requirements of the interface in customized versions of different clients, and improves the development efficiency of the web application. The method realizes the separation of baseline and customization in the customization of the web application, ensures that the smooth upgrade of the customization version can be realized when the baseline version is upgraded, and reduces the customization cost of the development of the web application.
Referring to fig. 3, a flowchart of a method for preprocessing a custom UI file according to an embodiment of the present application is shown. It should be noted that, the customized preprocessing device may be a web application development terminal or a web application client terminal. In the embodiment of the present application, a web application development terminal is taken as an example of a customization preprocessing device, and a method of taking a web application client as the customization preprocessing device is only different in terms of acquiring a baseline UI file and a customization UI instruction file, and a method of taking a web application client as the customization preprocessing device will be specifically described in the embodiment of fig. 4. In addition, the baseline UI file and the custom UI file in the embodiments of the present application are illustrated by using a hypertext markup language (Hypertext Markup Language, HTML) file as an example, and may be other files for describing the user interface presentation, which is not limited in the embodiments of the present application. The method comprises the following steps:
301. the custom preprocessing device loads the baseline UI file.
The customized preprocessing device analyzes the baseline UI file into a DOM tree structure through an HTML document programming interface.
302. And the customization preprocessing equipment loads a customization UI instruction file corresponding to the baseline UI file, wherein the customization UI instruction file contains customization UI instructions.
And the customization preprocessing equipment determines a customization UI instruction file corresponding to the baseline UI file by inquiring the configuration file, and acquires the customization UI instruction file. The configuration file is used for describing the corresponding relation between the baseline UI file and the custom UI instruction file; the custom preprocessing device can also obtain custom UI instruction files by processing command line parameters; the customization processing device may also send a request message again to the server to obtain the customization UI instruction file, or look up the customization UI instruction file locally. The embodiments of the present application are not limited.
The custom UI instruction file includes a custom UI instruction, which is used to describe how to perform custom processing on the baseline UI file, and may be an extensible markup language (Extensible Markup Language, XML) format file, or may be a file in another format, such as a JavaScript object notation (JavaScript object notation) format (JavaScript Object Notation, JSON), text (Text, TXT), comma Separated Values (CVS) format file, which is convenient for the custom preprocessing device to parse.
And the customization preprocessing equipment analyzes the customization UI instruction file through a programming interface, so that the customization UI instruction contained in the customization UI instruction file can be obtained. The customization preprocessing device sequentially traverses the customization UI instructions and processes the customization UI instructions piece by piece.
303. And determining a corresponding node in the baseline UI file according to the anchor point of the custom UI instruction, wherein the determination is based on the fact that the identifier of the node is identical to the anchor point.
And the customization preprocessing equipment searches corresponding nodes in the DOM tree, namely corresponding nodes in the baseline UI file, according to the anchor points of the customization UI instructions, and positions the nodes. In the DOM tree structure, the nodes are the most basic object types, and the identifiers of the nodes can uniquely identify one DOM node, so that the node identifiers are used as anchor points, and the customization preprocessing equipment can accurately position the nodes needing customization processing.
304. And skipping to corresponding processing logic according to the instruction name of the customization UI instruction, and performing customization processing on the node.
The customization UI instruction also comprises an instruction name, and the customization preprocessing equipment jumps to corresponding processing logic according to the instruction name of the current customization UI instruction to perform corresponding processing on the node needing customization. The instruction name is used to describe the custom processing to be done on the node, such as delete (insert), move (move), modify (modify) instructions, and so on.
When the instruction name of the custom UI instruction is delete, deleting the current node from the DOM tree;
When the instruction name of the custom UI instruction is insert, the DOM block contained in the instruction is inserted into the corresponding position of the current node according to the position attribute. The position attribute describes a relative position relation with the current node, for example, before the current node, after the current node, top at the top of the internal block of the current node, and bottom at the bottom of the internal block of the current node;
and when the instruction name of the custom UI instruction is move, searching a corresponding moving target node in the DOM tree according to the srcic attribute, and moving the DOM block of the current node to the corresponding position of the moving target node according to the position attribute. The srcic attribute describes node identifier information of the mobile destination node.
And when the instruction name of the custom UI instruction is modification, modifying the DOM element attribute of the current node according to the property/value key value pair defined by the instruction. For example, the attribute value of the attribute name property value of the current node is modified to a value.
The custom UI instructions are explained below, by way of example, as follows:
1) Deleting DOM block content corresponding to a node with a node identifier of 'additionInfo' (anchor point)
<delete anchorid＝“additionInfo”></delete>
2) After the node identifier is "inputNumber" (anchor), the content of the DOM chunk of the segment < bes: … > is inserted (position attribute):
3) The DOM chunk content corresponding to the node with the node identifier of "memory" (srcic) is moved to the position before the node identifier of "name" (anchor):
<move anchorid＝“name”position＝“before”srcid＝“memo”>
</move>
the description of the instruction names above is an example description, other definitions may be added to the instruction names, or the custom UI instruction may be newly added and the instruction names may be defined by themselves, so that the corresponding processing logic may be implemented in the program of the custom preprocessing device.
When the customization preprocessing device finishes processing one customization UI instruction, if the next customization UI instruction exists, the step 303 is skipped to continue execution; if the custom UI instructions in the custom UI instruction file are processed, the custom preprocessing device outputs the DOM tree which is currently custom processed in the memory as a custom UI file, and the file name of the custom UI file can be the same as that of the baseline UI file.
When the customization preprocessing device finishes processing the current baseline UI file, if the next baseline UI file with the corresponding customization UI instruction file exists, the step 301 is skipped to continue execution. If all the baseline UI files are preprocessed, corresponding custom UI files are formed, and the custom UI files are uploaded to a server by the custom preprocessing equipment.
It should be noted that, when the baseline version is upgraded, that is, there is an upgraded baseline UI file, the upgraded baseline UI file may be preprocessed again by using the corresponding custom UI file, so as to generate an upgraded custom UI file, thereby implementing synchronous upgrade of the custom version of the interface.
In the method for preprocessing and forming the customized UI file, the customized UI file is formed by preprocessing the base line UI file through the customized preprocessing equipment according to the customized UI instruction, and customization of user interface display is achieved. The method enables the front-end interface of the web application to be placed in the web baseline version, avoids the repeated development of similar requirements of the interface in customized versions of different clients, improves the development efficiency of the web application, and enables the complex functional interface to support flexible customization of display elements. The method provides non-invasive customization capability in interface display customization of the web application, realizes separation of baseline and customization, ensures smooth upgrade of the customization version when the baseline version is upgraded, and reduces customization cost of web application development.
Referring to fig. 4, a flowchart of another method for customizing a web application according to an embodiment of the present application is shown. The Web application client acquires the baseline UI file and the customization instruction UI file from the server, and as customization preprocessing equipment, the baseline UI file is preprocessed according to the customization instruction UI file to obtain the customization UI file, so that the customization of interface display is realized; the Web application client acquires the interaction logic file and the customization logic file from the server, and adopts an object-oriented class inheritance method to realize customization of interface logic processing. Step 401 is the same as step 201 in the embodiment shown in fig. 2, and will not be described here again. The method further comprises the steps of:
402. And the server returns a baseline UI file and a custom UI instruction file corresponding to the web application identifier.
The server receives the request message sent by the web application client and returns a corresponding baseline UI file and a customization UI instruction file according to the web application identifier.
And the server determines a customized UI instruction file corresponding to the corresponding baseline UI file by inquiring the configuration file, and acquires the customized UI instruction file. The configuration file is used for describing the corresponding relation between the baseline UI file and the custom UI instruction file. Alternatively, the server may also obtain the custom UI instruction file by processing the command line parameters, which is not limited in the embodiments of the present application.
The baseline UI file is a file facing all clients' similar needs for the user interface UI, and is used for describing the user interface presentation of the basic version. The custom UI instruction file includes a custom UI instruction, which is used to describe how to perform custom processing on the baseline UI file, and may be an extensible markup language (Extensible Markup Language, XML) format file, or may be a file in another format, such as a JavaScript object notation (JavaScript object notation) format (JavaScript Object Notation, JSON), text (Text, TXT), comma Separated Values (CVS) format file, which is convenient for the custom preprocessing device to parse.
It should be noted that, the server may also return only the baseline UI file in this step, and the web application client may obtain the custom UI instruction file by querying the configuration file or processing the command line parameters, etc., and the specific method refers to step 302 in the embodiment shown in fig. 3, which is not described herein again.
And 403, loading the baseline UI file and the custom UI instruction file by the Web application client, and preprocessing the baseline UI file according to the custom UI instruction in the custom UI instruction file to form the custom UI file.
The Web application client analyzes the baseline UI file into a DOM tree structure through an HTML document programming interface. And the Web application client analyzes the custom UI instruction file through a programming interface to obtain the custom UI instruction contained in the custom UI instruction file. The Web application client traverses the custom UI instructions sequentially and processes the custom UI instructions piece by piece.
The Web application client determines corresponding nodes in the baseline UI file according to the anchor points of the customization UI instructions, wherein the determination is based on the fact that identifiers of the nodes are identical to the anchor points; and skipping to corresponding processing logic according to the instruction name of the customization UI instruction, and performing customization processing on the node. Specific steps refer to steps 303-304 in the embodiment shown in fig. 3, which are not described herein, and the custom preprocessing device in the embodiment shown in fig. 3 is a Web application client in this embodiment.
The Web application client loads the customized UI file obtained through preprocessing and analyzes the customized UI file. It should be noted that, loading the UI customization file may be performed at the same time of preprocessing, or may be performed after preprocessing to form the customization UI file, which is not limited in this embodiment of the present application.
Steps 404-406 are similar to steps 204-206 of the embodiment of fig. 2 and are not described in detail herein.
It should be noted that, in the embodiment of the present application, the baseline UI file and the custom UI file are illustrated by using a hypertext markup language (Hypertext Markup Language, HTML) file as an example, and may be other files for describing the user interface presentation, which is not limited in the embodiment of the present application.
Compared with the embodiment shown in fig. 2, the method for customizing the web application provided by the embodiment of the application uses the web application client as the customizing preprocessing device to preprocess the baseline UI file to form the customizing UI file. On the basis of the embodiment shown in fig. 2, in the web application program debugging stage, the customized UI instruction file can be modified at the web application client, and the customized UI file is generated by real-time preprocessing, so that a developer can observe the change effect of the user interface in real time, and the development of web application customization is more convenient and flexible.
Please refer to fig. 5, which is a schematic diagram illustrating the composition of a web application client according to an embodiment of the present application. The web application client comprises:
a loading module 501, configured to load a customization UI file corresponding to the web application identifier, so as to implement customization of the user interface presentation. The specific implementation process can be described with reference to the steps in the embodiments shown in fig. 2 and fig. 4, such as step 203 and step 403;
-the loading module 501 is further configured to load an interaction logic file, the interaction logic file corresponding to the custom UI file. The interactive logic file is used for describing logic processing of the baseline version user interface, and may be a JS file. Specific implementation can be described with reference to the steps in the embodiments shown in fig. 2 and fig. 4, such as step 204 and step 404;
a determining module 502, configured to determine a custom logical subclass corresponding to a baseline logical parent class in the interaction logical file, where the custom logical subclass inherits a method and an attribute of the baseline logical parent class. The base line logic parent class is a base line class object in the interaction logic file, describes a method and an attribute of interface logic processing of a base line version, the custom logic subclass is a subclass object expanded in a class inheritance mode, and further describes a method and an attribute of interface logic processing required to be custom in a custom version on the basis of inheriting all the methods and the attributes of the base line logic parent class. The embodiment adopts an object-oriented mode to design the interaction logic, and the interaction logic of the baseline version is customized and expanded through class inheritance. Specific implementation can be described with reference to the steps in the embodiments shown in fig. 2 and fig. 4, such as step 205 and step 405;
-the loading module 501 is further configured to load a custom logic file corresponding to the custom logic subclass. The specific implementation process can be described with reference to the steps in the embodiments shown in fig. 2 and fig. 4, such as step 206 and step 406.
Specifically, the custom UI file is formed by preprocessing a baseline UI file by a custom preprocessing device, the preprocessing being based on custom UI instructions in a custom UI instruction file. The custom preprocessing device may be a web application hosting device, and the specific implementation may be described with reference to steps in the embodiment shown in fig. 3, such as steps 301-304. The custom preprocessing device may be a web application client and the specific implementation may be described with reference to the steps in the embodiment shown in fig. 4, as step 403.
Optionally, before the loading module 501 is configured to load the custom UI file, the method further includes:
-a sending module 503 for sending a request message to the server, the request message containing the web application identifier;
-a receiving module 504, configured to receive a baseline UI file corresponding to the web application identifier returned by the server;
-the loading module 501 is further configured to load a custom UI instruction file corresponding to the baseline UI file;
A preprocessing module 505, configured to preprocess the baseline UI file according to the customization UI instruction in the customization UI instruction file, to form the customization UI file.
This is by the web application client acting as a custom preprocessing device to preprocess the baseline UI file to form a custom UI file. The specific implementation is described with reference to steps in the embodiment shown in fig. 4, such as steps 401-403.
Specifically, the preprocessing module 505 is configured to form a customized UI file after preprocessing, and specifically includes:
-a determination submodule 5051 for determining a corresponding node in the baseline UI file from an anchor point of the custom UI instruction, the determination being based on an identifier of the node being identical to the anchor point;
-a customization processing sub-module 5052 for performing a customization process on the node according to the instruction name of the customization UI instruction by jumping to a corresponding processing logic.
The specific implementation may be described with reference to the steps in the embodiment shown in fig. 4, such as step 403.
Since the web application client provided in the embodiment of the present application may be used in the method for customizing the web application, the technical effects that can be obtained by the web application client may refer to the above method embodiment, and will not be described herein.
Referring to fig. 6, another schematic diagram of a web application client according to an embodiment of the present application is shown. Comprising at least one processor 601, a transceiver 602, and optionally a memory 603.
The memory 603 may be a volatile memory, such as a random access memory; the memory may also be a non-volatile memory such as, but not limited to, a read-only memory, a flash memory, a hard disk (HDD) or a Solid State Drive (SSD), or the memory 603 may be any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a computer. The memory 603 may be a combination of the above memories.
The specific connection medium between the processor 601 and the memory 603 is not limited in the embodiments of the present application. In the embodiment, the memory 603 and the processor 601 are connected through the bus 604, the bus 604 is shown with a thick line in the figure, and the connection manner between other components is only schematically illustrated and not limited. The bus 604 may be divided into an address bus, a data bus, a control bus, and the like. For ease of illustration, only one thick line is shown in fig. 6, but not only one bus or one type of bus.
The processor 601 may have data transceiving functions and be capable of communicating with other devices. As in the embodiments of the present application, the processor 601 may send a web file request message to a server, or may receive a custom UI file, a baseline UI file, a custom instruction UI file, an interaction logic file, or a related web file such as a custom logic file from the server. In the web application client as shown in fig. 6, a separate data transceiver module, such as transceiver 602, may also be provided for transceiving data; the processor 601 may also transmit data through the transceiver 602 when communicating with other devices, as in the embodiments of the present application, the processor 601 may send a web file request message to a server through the transceiver 602, and may also receive a related web file from the server through the transceiver 602.
The processor 601 may have a function of loading a parsing web file, for example, parsing a baseline UI file in HTML format into a DOM tree structure; the processor 601 may also have a preprocessing function, for example, preprocessing a baseline UI file according to a custom UI instruction file to form a custom UI file; the processor 601 may also read the web related files stored in the memory 603, for example, read the configuration file, and query whether the custom logic subclass is contained.
As an implementation, the functions of the transceiver 602 may be considered to be implemented by a transceiver circuit or a dedicated chip for transceiving. Processor 601 may be considered to be implemented by a dedicated processing chip, a processing circuit, a processor, or a general-purpose chip. For example, the processor 601 may be a central processing unit (Central Processing Unit, simply "CPU"), which may also be other general purpose processors, digital Signal Processors (DSPs), application Specific Integrated Circuits (ASICs), field Programmable Gate Arrays (FPGAs) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, or the like. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like.
As another implementation manner, a manner of using a general-purpose computer may be considered to implement the video server device provided in the embodiments of the present application. I.e. program code implementing the functions of the processor 601, transceiver 602 is stored in the memory 603, and the general purpose processor implements the functions of the processor 601, transceiver 602 by executing the code in the memory 603.
When the web application client takes the form shown in fig. 6, the processor 601 in fig. 6 may cause the web application client to perform the method performed by the web application client in the above-described method embodiment by invoking computer-executable instructions stored in the memory 603. The specific steps are described in the foregoing methods or other embodiments, and are not described herein.
It will be clearly understood by those skilled in the art that, for convenience and brevity of description, the specific working process of the apparatus and modules described above may refer to the corresponding process in the foregoing method embodiment, which is not repeated herein.
Referring to fig. 7, a schematic diagram of a web application customization system according to an embodiment of the present application is provided. The system comprises:
a web application client 701, a server 702, and a web application developer 703. The web application development terminal 703 is configured to preprocess the baseline UI file to generate a custom UI file, and upload the custom UI file, the interaction logic file, and the custom logic file to the server 702; the web application client 701 is configured to obtain the custom UI file, the interaction logic file, and the custom logic file from the server 702, load the custom UI file to implement customization of user interface presentation, load the custom logic file by using an object-oriented class inheritance method, instantiate a custom logic subclass, and change a handle pointing to a baseline logic parent class in the interaction logic file to point to the custom logic subclass, thereby implementing customization of logic processing of the user interface. Specific steps are described in the embodiments shown in fig. 2 and 3, and are not described herein.
Because the web application customization system provided in the embodiment of the present application may be used in the web application customization method, the technical effects that can be obtained by the system may refer to the above method embodiment, and will not be described herein.
The various numbers referred to in the embodiments of the present application are merely for convenience of description and are not intended to limit the scope of the embodiments of the present application. The sequence numbers of the above-mentioned processes do not mean the sequence of execution sequence, and the execution sequence of each process should be determined by its functions and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present application.
Those of ordinary skill in the art will appreciate that the various illustrative logical blocks (illustrative logical block) and steps (steps) described in connection with the embodiments disclosed herein can be implemented as electronic hardware, or combinations of computer software and electronic hardware. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the solution. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present application.
In the several embodiments provided in this application, it should be understood that the disclosed systems, devices, and methods may be implemented in other manners. For example, the apparatus embodiments described above are merely illustrative, and for example, the division of the modules is merely a logical function division, and there may be additional divisions when actually implemented, for example, multiple modules or components may be combined or integrated into another system, or some features may be omitted or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed with each other may be an indirect coupling or communication connection via some interfaces, devices or modules, which may be in electrical, mechanical, or other forms.
In the above embodiments, it may be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When loaded and executed on a computer, produces a flow or function in accordance with embodiments of the present application, in whole or in part. The computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable apparatus. The computer instructions may be stored in or transmitted from one computer-readable storage medium to another, for example, by wired (e.g., coaxial cable, optical fiber, digital Subscriber Line (DSL)), or wireless (e.g., infrared, wireless, microwave, etc.). The computer readable storage medium may be any available medium that can be accessed by a computer or a data storage device such as a server, data center, etc. that contains an integration of one or more available media. The usable medium may be a magnetic medium (e.g., floppy Disk, hard Disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., solid State Disk (SSD)), etc.
The foregoing is merely specific embodiments of the present application, but the scope of the present application is not limited thereto, and any person skilled in the art can easily think about changes or substitutions within the technical scope of the present application, and the changes and substitutions are intended to be covered by the scope of the present application. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.
Claims (9)
1. A method of web application customization, the method comprising:
the web application client loads a customized User Interface (UI) file corresponding to the web application identifier;
the web application client loads an interaction logic file, and the interaction logic file corresponds to the customized UI file;
the web application client determines a customized logic subclass corresponding to a baseline logic parent class in the interaction logic file, and the customized logic subclass inherits the method and the attribute of the baseline logic parent class;
the web application client loads a customized logic file corresponding to the customized logic subclass;
the custom UI file is formed by preprocessing the baseline UI file by a custom preprocessing device, wherein the preprocessing is based on custom UI instructions in a custom UI instruction file.
2. The method according to claim 1, characterized in that the pretreatment comprises in particular:
the customization preprocessing equipment determines corresponding nodes in the baseline UI file according to anchor points of the customization UI instructions, wherein the determination is based on the fact that identifiers of the nodes are identical to the anchor points;
and the customization preprocessing equipment jumps to corresponding processing logic according to the instruction name of the customization UI instruction, and performs customization processing on the node.
3. The method according to claim 1 or 2, wherein the customization pre-processing device comprises a web application launching end, and before the web application client loads the customization UI file corresponding to the web application identifier, further comprising:
the web application client sends a request message to a server, wherein the request message comprises the web application identifier;
the web application client receives the customized UI file corresponding to the web application identifier returned by the server, and the customized UI file is formed by preprocessing the baseline UI file by the web application development end and is uploaded to the server.
4. The method of claim 1 or 2, wherein the customization pre-processing device includes the web application client, and further comprising, before the web application client loads the customization UI file corresponding to the web application identifier:
The web application client sends a request message to a server, wherein the request message comprises the web application identifier;
the web application client receives a baseline UI file corresponding to the web application identifier returned by the server;
the web application client loads a customized UI instruction file corresponding to the baseline UI file;
and the web application client preprocesses the baseline UI file according to the custom UI instruction in the custom UI instruction file to form the custom UI file.
5. A web application client, comprising:
the loading module is used for loading the customized User Interface (UI) file corresponding to the web application identifier;
the loading module is further used for loading an interaction logic file, and the interaction logic file corresponds to the customized UI file; the customized UI file is formed by preprocessing a baseline UI file by customized preprocessing equipment, and the preprocessing is based on customized UI instructions in a customized UI instruction file;
the determining module is used for determining a customized logic subclass corresponding to a baseline logic parent class in the interaction logic file, wherein the customized logic subclass inherits the method and the attribute of the baseline logic parent class;
The loading module is further configured to load a custom logic file corresponding to the custom logic subclass.
6. The web application client of claim 5, wherein before the loading module is configured to load the custom UI file corresponding to the web application identifier, further comprising:
a sending module, configured to send a request message to a server, where the request message includes the web application identifier;
the receiving module is used for receiving a baseline UI file corresponding to the web application identifier returned by the server;
the loading module is further used for loading a customized UI instruction file corresponding to the baseline UI file;
and the preprocessing module is used for preprocessing the baseline UI file according to the custom UI instruction in the custom UI instruction file to form the custom UI file.
7. The web application client of claim 6, wherein the preprocessing module is configured to preprocess the baseline UI file according to the customization UI instruction to form the customization UI file, and specifically includes:
a determining sub-module, configured to determine, according to an anchor point of the custom UI instruction, a corresponding node in the baseline UI file, where the determining is based on an identifier of the node being the same as the anchor point;
And the customization processing sub-module is used for jumping to corresponding processing logic according to the instruction name of the customization UI instruction and carrying out customization processing on the node.
8. A web application customization system, comprising a web application development terminal, a server and a web application client terminal:
the web application development end is used for preprocessing the baseline UI file according to the custom UI instruction file to form a custom UI file, and sending the custom UI file to the server;
the web application client is used for acquiring the customized UI file from the server according to the web application identifier and loading the customized UI file;
the web application client is used for loading an interaction logic file, and the interaction logic file corresponds to the customized UI file;
the web application client is used for determining a customized logic subclass corresponding to a baseline logic parent class in the interaction logic file, and the customized logic subclass inherits the method and the attribute of the baseline logic parent class;
the web application client is used for loading the customized logic file corresponding to the customized logic subclass.
9. The system of claim 8, wherein the web application development terminal is configured to pre-process the baseline UI file according to the custom UI instruction file to form the custom UI file, and specifically includes:
The web application development end is used for determining corresponding nodes in the baseline UI file according to the anchor points of the customized UI instructions, and the determination is based on the fact that identifiers of the nodes are identical to the anchor points;
the web application development end is used for jumping to corresponding processing logic according to the instruction name of the customization UI instruction, and customizing the node.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910165259.4A CN111666074B (en) | 2019-03-05 | 2019-03-05 | A method, related device and system for customizing web applications |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910165259.4A CN111666074B (en) | 2019-03-05 | 2019-03-05 | A method, related device and system for customizing web applications |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111666074A CN111666074A (en) | 2020-09-15 |
| CN111666074B true CN111666074B (en) | 2024-04-09 |
Family
ID=72381724
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910165259.4A Active CN111666074B (en) | 2019-03-05 | 2019-03-05 | A method, related device and system for customizing web applications |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111666074B (en) |
Families Citing this family (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114356339A (en) * | 2021-12-29 | 2022-04-15 | 杭州安恒信息安全技术有限公司 | Service expansion method, device, equipment and computer readable storage medium |
| CN114860223B (en) * | 2022-07-06 | 2022-09-30 | 绍兴圆方半导体有限公司 | Interactive editing frame, interactive object generation method and electronic equipment |
| CN116088926B (en) * | 2023-01-10 | 2023-10-20 | 睿智合创(北京)科技有限公司 | Decision component version management method |
| CN116185454B (en) * | 2023-02-14 | 2026-02-27 | 恒生电子股份有限公司 | Application resource determination method, apparatus, server, and computer-readable storage medium |
Citations (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1924801A (en) * | 2006-09-21 | 2007-03-07 | 华为技术有限公司 | Solid mass-based software framework system and running method thereof |
| US7496843B1 (en) * | 2004-08-04 | 2009-02-24 | Sprint Communications Company L.P. | Web construction framework controller and model tiers |
| CN101685393A (en) * | 2008-08-20 | 2010-03-31 | 大唐软件技术股份有限公司 | Method and system for realizing interface dynamic customization and generation |
| US7761848B1 (en) * | 2005-03-15 | 2010-07-20 | Open Invention Network, Llc | Code generator tool for building software applications with reusable components |
| CN101840334A (en) * | 2010-04-16 | 2010-09-22 | 中国电子科技集团公司第二十八研究所 | Software component service packaging method |
| CN106843835A (en) * | 2016-12-21 | 2017-06-13 | 中国电子科技网络信息安全有限公司 | A kind of application systems software constructing system of meta data customizing, system constituting method |
| CN106980504A (en) * | 2017-03-28 | 2017-07-25 | 腾讯科技（深圳）有限公司 | A kind of application development method and its instrument, equipment |
| WO2017124976A1 (en) * | 2016-01-22 | 2017-07-27 | 阿里巴巴集团控股有限公司 | Method and device for acquiring application resource |
| CN107450923A (en) * | 2017-07-28 | 2017-12-08 | 郑州云海信息技术有限公司 | A kind of Program Realizing Method and device for customizing baseline separation |
| CN107688464A (en) * | 2017-06-28 | 2018-02-13 | 上海壹账通金融科技有限公司 | Software customized server, method and computer-readable recording medium |
| CN108122157A (en) * | 2017-12-19 | 2018-06-05 | 广州众赢资讯科技有限公司 | A kind of Dynamic Customization electric business interaction platform |
| CN108282518A (en) * | 2017-12-26 | 2018-07-13 | 阿里巴巴集团控股有限公司 | A kind of customer terminal webpage generation method and device |
Family Cites Families (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7694277B2 (en) * | 2003-05-14 | 2010-04-06 | Microsoft Corporation | Cross version customization of design environment |
| US9959114B2 (en) * | 2015-03-16 | 2018-05-01 | Microsoft Technology Licensing, Llc | Representation of customizable types in a development environment |
| KR101854975B1 (en) * | 2016-02-18 | 2018-05-04 | 라인 가부시키가이샤 | Method and system for extending function of package file |
| US10409565B2 (en) * | 2017-03-30 | 2019-09-10 | Ice Tea Group Llc | Pixel perfect real-time web application framework |
-
2019
- 2019-03-05 CN CN201910165259.4A patent/CN111666074B/en active Active
Patent Citations (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7496843B1 (en) * | 2004-08-04 | 2009-02-24 | Sprint Communications Company L.P. | Web construction framework controller and model tiers |
| US7761848B1 (en) * | 2005-03-15 | 2010-07-20 | Open Invention Network, Llc | Code generator tool for building software applications with reusable components |
| CN1924801A (en) * | 2006-09-21 | 2007-03-07 | 华为技术有限公司 | Solid mass-based software framework system and running method thereof |
| CN101685393A (en) * | 2008-08-20 | 2010-03-31 | 大唐软件技术股份有限公司 | Method and system for realizing interface dynamic customization and generation |
| CN101840334A (en) * | 2010-04-16 | 2010-09-22 | 中国电子科技集团公司第二十八研究所 | Software component service packaging method |
| WO2017124976A1 (en) * | 2016-01-22 | 2017-07-27 | 阿里巴巴集团控股有限公司 | Method and device for acquiring application resource |
| CN106843835A (en) * | 2016-12-21 | 2017-06-13 | 中国电子科技网络信息安全有限公司 | A kind of application systems software constructing system of meta data customizing, system constituting method |
| CN106980504A (en) * | 2017-03-28 | 2017-07-25 | 腾讯科技（深圳）有限公司 | A kind of application development method and its instrument, equipment |
| CN107688464A (en) * | 2017-06-28 | 2018-02-13 | 上海壹账通金融科技有限公司 | Software customized server, method and computer-readable recording medium |
| CN107450923A (en) * | 2017-07-28 | 2017-12-08 | 郑州云海信息技术有限公司 | A kind of Program Realizing Method and device for customizing baseline separation |
| CN108122157A (en) * | 2017-12-19 | 2018-06-05 | 广州众赢资讯科技有限公司 | A kind of Dynamic Customization electric business interaction platform |
| CN108282518A (en) * | 2017-12-26 | 2018-07-13 | 阿里巴巴集团控股有限公司 | A kind of customer terminal webpage generation method and device |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111666074A (en) | 2020-09-15 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107943547B (en) | Multi-service integration method, device, intelligent terminal, server and operating system | |
| US8521754B2 (en) | System and methods for web data transformation sourcing | |
| CN111666074B (en) | A method, related device and system for customizing web applications | |
| US9158510B2 (en) | System and computer program product for creating a telecommunications application | |
| EP2779582B1 (en) | Automatic mobile application discovery and integration in a mobile telecommunication device | |
| CN110764748B (en) | Code calling method, device, terminal and storage medium | |
| CN109240697B (en) | Call processing method and device and storage medium | |
| US20070280206A1 (en) | Method for consuming heterogeneous services on heterogeneous devices using script plugins | |
| CN101529382A (en) | Common component framework | |
| CN114528510B (en) | Webpage data processing method and device, electronic equipment and medium | |
| CN107729106A (en) | It is a kind of that the method and apparatus quickly redirected are realized between application component | |
| CN111651703A (en) | Page jump method and device, electronic equipment and readable storage medium | |
| US11930096B2 (en) | Systems and methods for rendering interactive web pages | |
| CN111880952A (en) | Application program jumping method and device, electronic equipment and storage medium | |
| CN113761871A (en) | Rich text rendering method, apparatus, electronic device and storage medium | |
| US20120054327A1 (en) | Site redirection | |
| US9411618B2 (en) | Metadata-based class loading using a content repository | |
| US20130124611A1 (en) | Unified repository & tool infrastructure | |
| CN114721929B (en) | Test method, device, storage medium and equipment | |
| CN115525305A (en) | Data processing, application starting method, device, computer equipment and storage medium | |
| CN112597423A (en) | Webpage content display method, terminal and server | |
| US12001458B2 (en) | Multi-cloud object store access | |
| CN115857898B (en) | Application system construction and operation method and device | |
| US8200713B2 (en) | Database exploration for building wireless component applications | |
| CN113448652A (en) | Request processing method and device |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |