A method for efficient and low-code application development based on common gene information

Abstract

The present invention proposes a data-based integrated model for low-code application development, and based on this, provides an efficient low-code application development method based on common genetic information. In view of the characteristics of the application program and its components in a tree-ordered organizational structure, the essential properties of the program and its components, including controls, menus, databases, etc., are condensed from top to bottom, and the extracted common information is used to form the DNA genetic information and value attribute value information of each element unit, etc., and the low-code application development integration model is formed by relying on two core data structures such as DNA and VDs, which effectively realizes the seamless integration of each element unit and realizes the integrated integration of data design, form design, and program development.

Description

Technical Field

[0001] The present invention belongs to the field of data processing technology, and specifically is a method for developing applications based on common genetic information for high efficiency and low code. Background Art

[0002] Well-known low-code development platforms generally use metadata to achieve integrated design and development. Metadata structures require a trade-off between flexibility and complexity. Flexibility requires a complex metadata system to ensure application scalability and customization of functional modules, but the design and implementation of complex metadata systems are difficult. Simplified metadata systems can ensure efficient development of low-code platforms, but they struggle to meet personalized needs.

[0003] Currently, an application is composed of several component elements from top to bottom, including form components, process components, page components, menu components, data components, identity components, and logic components. Each component is composed of several types. A top-down tree structure forms the connection between applications and components, and between components. Well-designed and well-executed applications primarily rely on the association between upper and lower-level components and data models, the configuration of linkages between components, and the triggering of linkages between components and functions. Summary of the Invention

[0004] To address the shortcomings of existing technologies, this paper proposes a deeply abstracted integration model. Through a metadata model, application development can be completed without changing existing component forms, leveraging only exposed interfaces. By condensing the common information of each component and generating DNA genetic information and value attribute information tailored to each component element, this paper fully leverages the recursive capabilities of information systems, enabling application development that effectively balances flexibility and complexity.

[0005] To achieve the above object, the present invention provides the following technical solutions:

[0006] An efficient low-code application development method includes the following steps:

[0007] Step S1: define and construct the common gene information of the application, and store the common gene information in a list;

[0008] Step S2: Construct query conditions to query the required common gene information;

[0009] Step S3: modify or add common gene information according to the ID, and retain the modified or added common gene information;

[0010] Step S4: Delete the corresponding common gene information by passing in the ID, and return the deletion information on the front end.

[0011] Furthermore, step S1 is specifically as follows:

[0012] Applications include form components, process components, page components, menu components, data components, identity components, and logic components;

[0013] The common genetic information DNA of all components is abstracted and formalized as follows:

[0014] DNA={id, dnaCode, dnaName, List <dna>children,List <dna>parent,Vds};

[0015] Among them, id is the DNA structure number, dnaCode is the category corresponding to the gene, List <dna>Children represents a list of subcomponents, List <dna>parent represents the parent component list, Vds represents the attribute list, dnaName indicates the name corresponding to the gene, and children and parent are list types. Relying on these two data structures, a closed loop of recursive capabilities is implemented, which can realize the tree-order shape of the top-down gene structure and ensure the top-down traversal or bottom-up backtracking of each component;

[0016] Vds is a property list of type Vd, defined as:

[0017] Vd={id, vdCode, vdName, dnaId, databaseName, tableName, dataType}.

[0018] Among them, id is the data table serial number corresponding to the attribute, vdCode is the component attribute category, vdName is the attribute name, dnaId is the pointer to the dna to which this data belongs, databaseName specifies the database corresponding to this attribute information, tableName specifies the table corresponding to this attribute information, and dataType is the data type of this data.

[0019] Furthermore, step S2 is specifically as follows:

[0020] Step S21: The backend obtains the parameters dnaCode and dnaName passed by the frontend;

[0021] Step S22: Determine whether dnaName and dnaCode are empty. If they are empty, they are not considered as query conditions. Otherwise, they are combined into query conditions.

[0022] Step S23: The backend gets the passed data and performs fuzzy matching in the metametadna management table;

[0023] Step S24: The backend displays the matched common gene information on the front end.

[0024] Furthermore, step S3 is specifically as follows:

[0025] Step S31: The back end obtains the DNA and Vds transferred from the front end;

[0026] Step S32: Determine whether Vds has an ID. If so, modify it. If not, add it. Specifically, update the ID accordingly in the backend.

[0027] Step S33: storing the assembled DNA into the metametaDNA management table;

[0028] Step S34: first delete the data with the same dnaId in the metavd management table, then traverse Vds and save it to metavd;

[0029] Step S35: The background saves the data and returns the generated data to the front end.

[0030] Furthermore, step S4 is specifically as follows:

[0031] Step S41: The front-end user page interface inputs the id;

[0032] Step S42: After obtaining the ID, determine whether the ID exists. If not, return the corresponding message to the front end. If it exists, execute step S43;

[0033] Step S43: Get the record corresponding to the input ID in the metadna management table and delete it;

[0034] Step S44: The backend returns success / failure to the frontend, and the frontend prompts and refreshes.

[0035] Furthermore, dynamic thresholds are set to abstract the common genetic information DNA of all components, specifically:

[0036] For each common gene information, a dynamic threshold is set. The threshold is determined based on the frequency of use, importance, or business logic of the component, and is expressed as:

[0037] Threshold=f(Usage,Importance,BusinessLogic)Threshold=f(Usage,Importance,BusinessLogic)

[0038] Among them: UsageUsage is the usage frequency of the component, Importance is the importance parameter of the component, BusinessLogicBusinessLogic is the factor related to business logic, and f represents the threshold calculation function, which calculates the threshold based on the above factors.

[0039] Furthermore, steps S2 to S4 can be executed in parallel.

[0040] Compared with the prior art, the present invention has the following beneficial effects:

[0041] 1. This invention proposes a deeply abstracted integration model. Through the metadata model, the application development process can be completed by only using the exposed interfaces without changing the existing component form.

[0042] 2. By condensing the common information of each component and forming DNA gene information and value attribute value information that adapt to each component element unit, we can fully utilize the recursive capability of the information system to achieve application development that can effectively balance flexibility and complexity.

[0043] 3. By setting dynamic thresholds to abstract common gene information, the flexibility in the application development process is improved. BRIEF DESCRIPTION OF THE DRAWINGS

[0044] Figure 1 This is a flowchart of the steps of a method for efficient and low-code application development based on common genetic information. DETAILED DESCRIPTION

[0045] To make the technical means, creative features, objectives and effects achieved by the present invention easily understood, it should be noted that in the description of the present invention, the terms "center", "up", "down", "left", "right", "vertical", "horizontal", "inside", "outside" and the like indicate positions or positional relationships based on the positions or positional relationships shown in the accompanying drawings. They are only for the convenience of describing the present invention and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, be constructed and operate in a specific orientation. Therefore, they should not be understood as limiting the present invention. In addition, the terms "number one", "number two", and "number three" are used for descriptive purposes only and should not be understood as indicating or implying relative importance. The present invention will be further described below in conjunction with specific embodiments.

[0046] Reference Figure 1 , a method for efficient and low-code application development based on common gene information, comprising the following steps:

[0047] Step S1: define and construct the common gene information of the application, and store the common gene information in a list;

[0048] Step S2: Construct query conditions to query the required common gene information;

[0049] Step S3: modify or add common gene information according to the ID, and retain the modified or added common gene information;

[0050] Step S4: Delete the corresponding common gene information by passing in the ID, and return the deletion information on the front end.

[0051] Furthermore, step S1 is specifically as follows:

[0052] Applications include form components, process components, page components, menu components, data components, identity components, and logic components;

[0053] The common genetic information DNA of all components is abstracted and formalized as follows:

[0054] DNA={id, dnaCode, dnaName, List <dna>children,List <dna>parent,Vds};

[0055] Among them, id is the DNA structure number, dnaCode is the category corresponding to the gene, List <dna>Children represents a list of subcomponents, List <dna>parent represents the parent component list, Vds represents the attribute list, dnaName indicates the name corresponding to the gene, and children and parent are list types. Relying on these two data structures, a closed loop of recursive capabilities is implemented, which can realize the tree-order shape of the top-down gene structure and ensure the top-down traversal or bottom-up backtracking of each component;

[0056] Vds is a property list of type Vd, defined as:

[0057] Vd={id, vdCode, vdName, dnaId, databaseName, tableName, dataType}.

[0058] Among them, id is the data table serial number corresponding to the attribute, vdCode is the component attribute category, vdName is the attribute name, dnaId is the pointer to the dna to which this data belongs, databaseName specifies the database corresponding to this attribute information, tableName specifies the table corresponding to this attribute information, and dataType is the data type of this data.

[0059] Furthermore, step S2 is specifically as follows:

[0060] Step S21: The backend obtains the parameters dnaCode and dnaName passed by the frontend;

[0061] Step S22: Determine whether dnaName and dnaCode are empty. If they are empty, they are not considered as query conditions. Otherwise, they are combined into query conditions.

[0062] Step S23: The backend gets the passed data and performs fuzzy matching in the metametadna management table;

[0063] Step S24: The backend displays the matched common gene information on the front end.

[0064] Furthermore, step S3 is specifically as follows:

[0065] Step S31: The back end obtains the DNA and Vds transferred from the front end;

[0066] Step S32: Determine whether Vds has an ID. If so, modify it. If not, add it. Specifically, update the ID accordingly in the backend.

[0067] Step S33: storing the assembled DNA into the metametaDNA management table;

[0068] Step S34: first delete the data with the same dnaId in the metavd management table, then traverse Vds and save it to metavd;

[0069] Step S35: The background saves the data and returns the generated data to the front end.

[0070] Furthermore, step S4 is specifically as follows:

[0071] Step S41: The front-end user page interface inputs the id;

[0072] Step S42: After obtaining the ID, determine whether the ID exists. If not, return the corresponding message to the front end. If it exists, execute step S43;

[0073] Step S43: Get the record corresponding to the input ID in the metadna management table and delete it;

[0074] Step S44: The backend returns success / failure to the frontend, and the frontend prompts and refreshes.

[0075] Furthermore, dynamic thresholds are set to abstract the common genetic information DNA of all components, specifically:

[0076] For each common gene information, a dynamic threshold is set. The threshold is determined based on the frequency of use, importance, or business logic of the component, and is expressed as:

[0077] Threshold=f(Usage,Importance,BusinessLogic)Threshold=f(Usage,Importance,BusinessLogic)

[0078] Among them: UsageUsage is the usage frequency of the component, Importance is the importance parameter of the component, BusinessLogicBusinessLogic is the factor related to business logic, and f represents the threshold calculation function, which calculates the threshold based on the above factors.

[0079] Furthermore, steps S2 to S4 can be executed in parallel.

[0080] The above-described specific embodiments further illustrate the objectives, technical solutions, and beneficial effects of the present invention. It should be understood that the above description is merely a specific embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present invention shall be included within the scope of protection of the present invention.< / dna> < / dna> < / dna> < / dna> < / dna> < / dna> < / dna> < / dna>

Claims

1. A method for efficient and low-code application development based on common gene information, characterized in that: The following steps are involved: Step S1: define and construct the common gene information of the application, and store the common gene information in a list; Step S2: construct query conditions to query the required common gene information; Step S3: modify or add common gene information according to the ID, and retain the modified or added common gene information; Step S4: Delete the corresponding common gene information by passing in the ID, and return the deletion information at the front end.

2. According to claim 1, a method for high-efficiency and low-code application development based on common gene information is characterized in that: Step S1 is specifically as follows: The application includes form components, process components, page components, menu components, data components, identity components, and logic components; The common genetic information DNA of all components is abstracted and formalized as follows: DNA={id,dnaCode,dnaName,List <dna>children, List <dna> parent, Vds};< / dna> < / dna> Among them, id is the DNA structure number, dnaCode is the category corresponding to the gene, List <dna>Children represents a list of child components, List <dna> parent indicates the parent component list, Vds indicates the attribute list, dnaName indicates the name corresponding to the gene, children and parent are list types, and the closed loop of recursive capability is realized by relying on these two data structures, which can realize the tree order shape of the top-down gene structure and ensure the top-down traversal or bottom-up backtracking of each component;< / dna> < / dna> Vds is a property list of type Vd, defined as: Vd={id, vdCode, vdName, dnaId, databaseName, tableName, dataType}; Among them, id is the data table serial number corresponding to the attribute, vdCode is the component attribute category, vdName is the attribute name, dnaId is a pointer to the dna to which this data belongs, databaseName specifies the database corresponding to this attribute information, tableName specifies the table corresponding to this attribute information, and dataType is the data type of this data.

3. According to claim 1, a method for high-efficiency and low-code application development based on common gene information is characterized in that: Step S2 is specifically as follows: Step S21: The backend obtains the parameters dnaCode and dnaName passed by the frontend; Step S22: determine whether dnaName and dnaCode are empty, if so, they are not considered as query conditions, otherwise they are combined into query conditions; Step S23: The backend gets the transmitted data and performs fuzzy matching in the metametadna management table; Step S24: The backend displays the matched common gene information on the front end.

4. According to claim 1, a method for high-efficiency and low-code application development based on common gene information is characterized in that: Step S3 is specifically as follows: Step S31: the back end obtains the DNA and Vds transmitted by the front end; Step S32: determine whether Vds has an id, if yes, modify it, if no, add it, specifically update the id accordingly in the backend; Step S33: storing the assembled DNA into the metametaDNA management table; Step S34: first delete the data with the same dnaId in the metavd management table, then traverse Vds and save them in metavd; Step S35: After the background saves the data, it returns the generated data to the front end.

5. According to claim 1, a method for high-efficiency and low-code application development based on common gene information is characterized in that: Step S4 is specifically as follows: Step S41: the front-end user page interface inputs the id; Step S42: After obtaining the id, determine whether the id exists. If not, return the corresponding message to the front end. If it exists, execute step S43; Step S43: Get the record corresponding to the input id in the metadna management table and delete it; Step S44: The backend returns success / failure to the frontend, and the frontend prompts and refreshes.

6. The method for high-efficiency and low-code application development based on common gene information according to claim 1, characterized in that: Steps S2 to S4 can be executed in parallel.

7. The method for high-efficiency and low-code application development based on common gene information according to claim 1, characterized in that: Set dynamic thresholds to abstract the common genetic information DNA of all components, specifically: For each common gene information, a dynamic threshold is set. The threshold is determined based on the frequency of use, importance, or business logic of the component, expressed as: Threshold=f(Usage,Importance,BusinessLogic)Threshold=f(Usage,Importance,BusinessLogic); Wherein: UsageUsage is the usage frequency of the component, Importance is the importance parameter of the component, BusinessLogicBusinessLogic is a factor related to business logic, and f represents the threshold calculation function, which calculates the threshold based on the above factors.

Images