CN117950652A - Component ecological application development method based on low-code platform - Google Patents
Component ecological application development method based on low-code platform Download PDFInfo
- Publication number
- CN117950652A CN117950652A CN202410024604.3A CN202410024604A CN117950652A CN 117950652 A CN117950652 A CN 117950652A CN 202410024604 A CN202410024604 A CN 202410024604A CN 117950652 A CN117950652 A CN 117950652A
- Authority
- CN
- China
- Prior art keywords
- component
- components
- version
- platform
- file
- 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.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 45
- 238000011161 development Methods 0.000 title claims abstract description 27
- 239000000306 component Substances 0.000 claims abstract description 354
- 230000006870 function Effects 0.000 claims abstract description 18
- 239000008358 core component Substances 0.000 claims abstract description 16
- 238000013461 design Methods 0.000 claims abstract description 11
- 238000007726 management method Methods 0.000 claims description 19
- 230000006978 adaptation Effects 0.000 claims description 12
- 238000012360 testing method Methods 0.000 claims description 10
- 238000013499 data model Methods 0.000 claims description 9
- 230000003993 interaction Effects 0.000 claims description 9
- 238000004458 analytical method Methods 0.000 claims description 6
- 230000010354 integration Effects 0.000 claims description 6
- 238000012795 verification Methods 0.000 claims description 6
- 230000005540 biological transmission Effects 0.000 claims description 4
- 238000012545 processing Methods 0.000 claims description 4
- 230000005587 bubbling Effects 0.000 claims description 3
- 238000009960 carding Methods 0.000 claims description 3
- 230000008859 change Effects 0.000 claims description 3
- 238000006243 chemical reaction Methods 0.000 claims description 3
- 238000010276 construction Methods 0.000 claims description 3
- 238000013524 data verification Methods 0.000 claims description 3
- 230000001419 dependent effect Effects 0.000 claims description 3
- 238000010586 diagram Methods 0.000 claims description 3
- 230000000694 effects Effects 0.000 claims description 3
- 238000005516 engineering process Methods 0.000 claims description 3
- 238000011156 evaluation Methods 0.000 claims description 3
- 239000012634 fragment Substances 0.000 claims description 3
- 238000004519 manufacturing process Methods 0.000 claims description 3
- 238000004806 packaging method and process Methods 0.000 claims description 3
- 238000009877 rendering Methods 0.000 claims description 3
- 230000004044 response Effects 0.000 claims description 3
- 238000013519 translation Methods 0.000 claims description 3
- 238000012800 visualization Methods 0.000 claims description 3
- 238000005096 rolling process Methods 0.000 claims 1
- 238000009781 safety test method Methods 0.000 claims 1
- 230000008569 process Effects 0.000 description 3
- 238000011990 functional testing Methods 0.000 description 2
- 238000011056 performance test Methods 0.000 description 2
- 238000011076 safety test Methods 0.000 description 2
- 238000012546 transfer Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000007812 deficiency Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000003908 quality control method Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/34—Graphical or visual programming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
- G06F11/14—Error detection or correction of the data by redundancy in operation
- G06F11/1402—Saving, restoring, recovering or retrying
- G06F11/1446—Point-in-time backing up or restoration of persistent data
- G06F11/1458—Management of the backup or restore process
- G06F11/1469—Backup restoration techniques
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR 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; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/61—Installation
- G06F8/62—Uninstallation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/65—Updates
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02P—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN THE PRODUCTION OR PROCESSING OF GOODS
- Y02P90/00—Enabling technologies with a potential contribution to greenhouse gas [GHG] emissions mitigation
- Y02P90/30—Computing systems specially adapted for manufacturing
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Quality & Reliability (AREA)
- Computer Security & Cryptography (AREA)
- Computer Hardware Design (AREA)
- Stored Programmes (AREA)
Abstract
The invention relates to the technical field of application program development, in particular to a component ecological application development method based on a low-code platform. The component ecological application development method based on the low-code platform comprises the following steps: step one, defining a set of mature component standard specifications, including design principles, structure definitions and interface rules, so as to ensure the high multiplexing and compatibility of the components; meanwhile, the components are classified into three types according to their functions and characteristics: an immutable common core component, a variably adapted core component, and a user-specific extension component. The components can be flexibly adjusted and expanded according to different service scenes and requirements; the configurability and the expandability of the components are improved.
Description
Technical Field
The invention relates to the technical field of application program development, in particular to a component ecological application development method based on a low-code platform.
Background
A component refers to a separate, reusable software unit that is used to build a more complex system or application. Components typically have well-defined interfaces and functions such that they interoperate and combine in different systems and applications.
With the increasing level of informatization, software systems are increasingly in demand. However, the traditional application program has long development period and high cost, and is difficult to meet the requirements of quick iteration and individuation. The low-code platform is used as a novel development mode, can help developers to quickly build applications, and shortens development period. However, the prior art suffers from a number of deficiencies in component design and management, such as limited component selection, difficulty in quality control, reliance and version control inconveniences, and lack of standardized component development flow specifications. These problems limit the delivery efficiency of low code platforms on the business line and the reusability of components.
Disclosure of Invention
In order to overcome the above disadvantages, the present invention provides a component ecological application development method based on a low-code platform.
The technical proposal is as follows: the component ecological application development method based on the low-code platform comprises the following steps: stage one, defining a set of mature component standard specifications, including design rules, structural definitions, interface rules, etc., to ensure high reuse and compatibility of components. Meanwhile, the components are classified into three types according to their functions and characteristics:
Immutable common core components: is the core of the application program, is not influenced by user customization, and provides stable basic functions including data model, workflow operation, standard integration and the like.
Variable adaptation core component: is an adjustable part of the application program (component) by a user, and is adjusted according to different business scenes and requirements, so that flexible adaptation capability is provided, and the flexible adaptation capability comprises workflow, data model expansion, customizable pages and fragments, topics, expandable micro-flows, translation, terminology and the like.
User-specific extension component: the part for customizing the functions for the user needs is developed according to the personalized needs of the user, and rich expansion capability is provided, including integration with the existing system, additional visualization and the like.
Preferably, the design principle of the assembly may be according to common standards in the art.
Preferably, the structural definition of the assembly comprises the following parts: component metadata: basic information of a component, including component name, component description, component type, component version, component author, component tag, etc., is used for identification and management of the component.
Component template: the UI portion of the component, including the HTML structure, CSS style, javaScript logic, etc. of the component, is used for rendering and interaction of the component.
Component properties: the configuration part of the component comprises attribute definition, attribute type, attribute default value, attribute verification rule and the like of the component, and is used for the self-definition and verification of the component.
Component document: the description of the components, including functional description of the components, methods of use, example code, notes, etc., is for understanding and learning of the components.
Preferably, the interface rule of the component comprises the following parts: and (3) a data interface: data input and output of the component, including data source, data model, data format, data conversion, data verification, etc. of the component, are used for data processing and transfer of the component.
Event interface: event triggers and responses of the component, including event types, event parameters, event callbacks, event bubbling, etc. of the component are used for event handling and notification of the component.
The method comprises the following steps: the method call and return of the component includes the method name, method parameters, method return value, method exception, etc. of the component for the method execution and return of the component.
Life cycle interface: the lifecycle hooks of the components, including creation, mounting, updating, unloading, etc. of the components, are used for lifecycle management and control of the components.
And step two, developing brand new component ecological application, so that a developer can arrange component logic and constitution through a designer, and provide a standard development flow which runs through requirements, technologies and test the whole production link. The component ecological application development flow is as follows:
Initializing: the development environment of the component is initialized by using the CLI tool provided by the platform, and the basic structure and configuration file of the component are generated.
Demand analysis: and (3) carrying out analysis and construction of the company components based on service carding, identifying service requirements and pain points, determining functions and ranges of the components, and selecting proper component types and specifications.
Designing a sketch: the UI and interactions of the components are designed, prototype diagrams and flowcharts of the components are drawn, and the layout and logic of the components are determined.
Coding design: writing templates, attributes, interfaces, etc. of the components; resources required by writing the components, including pages, rights, micro-streams, dependencies, and the like; the effects of the components are quickly developed and previewed using the designer and scaffold tools provided by the platform.
Joint debugging: the developer carries out real-time joint debugging through the designer, checks interaction and data transmission among the components, and debugs the functions and performances of the components.
And (3) testing and verifying: the components are comprehensively tested, including functional tests, performance tests, safety tests and the like, so that the correctness and reliability of the components are ensured, and meanwhile, feedback and evaluation of users are collected, and the components are continuously improved.
And (3) issuing: the developer needs to use CLI tools provided by the platform, package component resources, generate component packages, publish components through the designer, upload component packages to a component library, or directly deploy into an application.
Preferably, the package is in a zip file format, including the following files:
manift. Json: metadata files for component packages, including the name, description, version, author, tag, etc. of the component package, are used for identification and management of the component package.
Page. Zip: the page file of the component package contains the page resources of the component for the UI section of the component.
Permission. Zip: the rights file of the package of components contains the rights resources of the components for the access control part of the components.
Microflow. Zip: the micro-stream file of the component package contains the micro-stream resources of the component for the business logic portion of the component.
Dependency. Zip: the dependency file of the component package contains the dependent resources of the component for the associated portion of the component.
Stage three, defining the variable and non-variable parts of the component, provides unified version management for the non-variable parts.
For a common core component that is not changeable: the platform provides unified version management, records the update history of the component, supports the upgrade and rollback of the component, and ensures the stability and safety of the component.
For a variable adaptation core and user specific extension component: the developer manages the version of the component by itself, modifies and optimizes the component according to the service demand and user feedback, and improves the quality and satisfaction of the component.
Preferably, for the version management of the immutable common core component, the specific flow is as follows:
Packaging the components into component packages, uploading the component packages to a component library, or directly deploying the component packages into an application; when publishing, the version number of the component needs to be specified, the semantically compliant version specification is followed, and an x.y.z format is used, wherein x represents the major version number, y represents the minor version number, and z represents the revision number.
The developer upgrades the immutable component according to the requirement or feedback, then reissues the component, upgrades the version number of the component, and the following principle needs to be followed:
If only the bug of the component is repaired or the performance of the component is improved, only the revision number needs to be increased, for example, from 1.0.0 to 1.0.1.
If the functionality or properties of the component are increased, but the compatibility of the component is not affected, only the minor version number needs to be increased, e.g. from 1.0.0 to 1.1.0.
If the functionality or properties of the component are modified, resulting in a change in compatibility of the component, the major version number needs to be increased, e.g., from 1.0.0 to 2.0.0.
Rollback immutable component: the developer rolls back the immutable component through a rollback tool provided by the platform, restores the component to a previous version, and solves the problem or error of the component. Upon rollback, it is necessary to specify the version number of the component, select the version to rollback to, and then confirm the rollback operation.
The beneficial effects are that: 1. by defining a set of mature component standard specifications, including design rules, structural definitions, interface rules, etc., the high multiplexing and compatibility of components is improved. The components are divided into an invariable public core component, a changeable adaptation core component and a user-specific expansion component, and the components are flexibly adjusted and expanded according to different service scenes and requirements; the configurability and the expandability of the components are improved.
2. Through perfect component development flow and using a platform designer, real-time joint debugging and comprehensive testing are carried out on the components, so that the correctness and reliability of the components are ensured, and meanwhile, the standard specification and requirements of a platform are met.
3. Through version management and rollback tools, the components are uniformly managed and controlled, the update history of the components is recorded, rollback and upgrading of the components are supported, and traceability and restorability of the components are ensured.
Drawings
FIG. 1 is a flow chart of the development of the component ecology application based on the low code platform of the present invention.
Detailed Description
The invention will now be described in more detail with reference to the drawings and specific examples, which are not intended to limit the invention thereto.
As shown in fig. 1, the component ecological application development method based on the low-code platform comprises the following stages: stage one, defining a set of mature component standard specifications, including design rules, structural definitions, interface rules, etc., to ensure high reuse and compatibility of components. Meanwhile, the components are classified into three types according to their functions and characteristics:
Immutable common core components: is the core of the application program, is not influenced by user customization, and provides stable basic functions including data model, workflow operation, standard integration and the like.
Variable adaptation core component: is an adjustable part of the application program (component) by a user, and is adjusted according to different business scenes and requirements, so that flexible adaptation capability is provided, and the flexible adaptation capability comprises workflow, data model expansion, customizable pages and fragments, topics, expandable micro-flows, translation, terminology and the like.
User-specific extension component: the part for customizing the functions for the user needs is developed according to the personalized needs of the user, and rich expansion capability is provided, including integration with the existing system, additional visualization and the like.
In specific implementations, the design of the components may be in accordance with common standards in the art.
In a specific implementation, the structural definition of the component includes the following parts: component metadata: basic information of a component, including component name, component description, component type, component version, component author, component tag, etc., is used for identification and management of the component.
Component template: the UI portion of the component, including the HTML structure, CSS style, javaScript logic, etc. of the component, is used for rendering and interaction of the component.
Component properties: the configuration part of the component comprises attribute definition, attribute type, attribute default value, attribute verification rule and the like of the component, and is used for the self-definition and verification of the component.
Component document: the description of the components, including functional description of the components, methods of use, example code, notes, etc., is for understanding and learning of the components.
In a specific implementation process, the interface rule of the component comprises the following parts: and (3) a data interface: data input and output of the component, including data source, data model, data format, data conversion, data verification, etc. of the component, are used for data processing and transfer of the component.
Event interface: event triggers and responses of the component, including event types, event parameters, event callbacks, event bubbling, etc. of the component are used for event handling and notification of the component.
The method comprises the following steps: the method call and return of the component includes the method name, method parameters, method return value, method exception, etc. of the component for the method execution and return of the component.
Life cycle interface: the lifecycle hooks of the components, including creation, mounting, updating, unloading, etc. of the components, are used for lifecycle management and control of the components.
And thirdly, developing brand new component ecological application, so that a developer can arrange component logic and constitution through a designer, and provide a standard development flow which runs through requirements, technologies and test the whole production link. The component ecological application development flow is as follows:
Initializing: the development environment of the component is initialized by using the CLI tool provided by the platform, and the basic structure and configuration file of the component are generated.
Demand analysis: and (3) carrying out analysis and construction of the company components based on service carding, identifying service requirements and pain points, determining functions and ranges of the components, and selecting proper component types and specifications.
Designing a sketch: the UI and interactions of the components are designed, prototype diagrams and flowcharts of the components are drawn, and the layout and logic of the components are determined.
Coding design: writing templates, attributes, interfaces, etc. of the components; resources required by writing the components, including pages, rights, micro-streams, dependencies, and the like; the effects of the components are quickly developed and previewed using the designer and scaffold tools provided by the platform.
Joint debugging: the developer carries out real-time joint debugging through the designer, checks interaction and data transmission among the components, and debugs the functions and performances of the components.
And (3) testing and verifying: the components are comprehensively tested, including functional tests, performance tests, safety tests and the like, so that the correctness and reliability of the components are ensured, and meanwhile, feedback and evaluation of users are collected, and the components are continuously improved.
And (3) issuing: the developer needs to use CLI tools provided by the platform, package component resources, generate component packages, publish components through the designer, upload component packages to a component library, or directly deploy into an application.
In the implementation process, the package format is a zip file, including the following files:
manift. Json: metadata files for component packages, including the name, description, version, author, tag, etc. of the component package, are used for identification and management of the component package.
Page. Zip: the page file of the component package contains the page resources of the component for the UI section of the component.
Permission. Zip: the rights file of the package of components contains the rights resources of the components for the access control part of the components.
Microflow. Zip: the micro-stream file of the component package contains the micro-stream resources of the component for the business logic portion of the component.
Dependency. Zip: the dependency file of the component package contains the dependent resources of the component for the associated portion of the component.
Stage three, defining the variable and non-variable parts of the component, provides unified version management for the non-variable parts.
For a common core component that is not changeable: the platform provides unified version management, records the update history of the component, supports the upgrade and rollback of the component, and ensures the stability and safety of the component.
For a variable adaptation core and user specific extension component: the developer manages the version of the component by itself, modifies and optimizes the component according to the service demand and user feedback, and improves the quality and satisfaction of the component.
In the implementation process, for the version management of the immutable public core component, the specific flow is as follows:
Packaging the components into component packages, uploading the component packages to a component library, or directly deploying the component packages into an application; when publishing, the version number of the component needs to be specified, the semantically compliant version specification is followed, and an x.y.z format is used, wherein x represents the major version number, y represents the minor version number, and z represents the revision number.
The developer upgrades the immutable component according to the requirement or feedback, then reissues the component, upgrades the version number of the component, and the following principle needs to be followed:
If only the bug of the component is repaired or the performance of the component is improved, only the revision number needs to be increased, for example, from 1.0.0 to 1.0.1.
If the functionality or properties of the component are increased, but the compatibility of the component is not affected, only the minor version number needs to be increased, e.g. from 1.0.0 to 1.1.0.
If the functionality or properties of the component are modified, resulting in a change in compatibility of the component, the major version number needs to be increased, e.g., from 1.0.0 to 2.0.0.
Rollback immutable component: the developer rolls back the immutable component through a rollback tool provided by the platform, restores the component to a previous version, and solves the problem or error of the component. Upon rollback, it is necessary to specify the version number of the component, select the version to rollback to, and then confirm the rollback operation.
The embodiments described above are intended to provide those skilled in the art with a full range of modifications and variations to the embodiments described above without departing from the inventive concept thereof, and therefore the scope of the invention is not limited by the embodiments described above, but is to be accorded the broadest scope consistent with the innovative features recited in the claims.
Claims (7)
1. The component ecological application development method based on the low-code platform is characterized by comprising the following stages:
Step one, defining a set of mature component standard specifications, including design principles, structure definitions and interface rules, so as to ensure the high multiplexing and compatibility of the components; meanwhile, the components are classified into three types according to their functions and characteristics:
immutable common core components: the method is a core of an application program, is not influenced by user customization, and provides stable basic functions including data model, workflow operation and standard integration;
Variable adaptation core component: the method is an adjustable part in the application program, and is adjusted according to different business scenes and requirements by a user to provide flexible adaptation capability, and comprises workflow, data model expansion, customizable pages and fragments, topics, expandable micro-flows, translation and terms;
User-specific extension component: the part for customizing the functions for the user needs is developed according to the personalized needs of the user, and rich expansion capability is provided, including integration with the existing system and additional visualization; step two, developing brand new component ecological application, so that a developer can arrange component logic and constitution through a designer, and provide a standard development flow which runs through requirements, technologies and test the whole production link;
Stage three, defining variable and non-variable parts of the component, and providing unified version management for the non-variable parts; for a common core component that is not changeable: the platform provides unified version management, records the update history of the component, supports the upgrade and rollback of the component, and ensures the stability and safety of the component;
for a variable adaptation core and user specific extension component: the developer manages the version of the component by itself, modifies and optimizes the component according to the service demand and user feedback, and improves the quality and satisfaction of the component.
2. The low code platform based component ecological application development method of claim 1, wherein the structural definition of the component comprises the following parts:
Basic information of the component, including component name, component description, component type, component version, component author, component label, for identification and management of the component;
The UI part of the component comprises an HTML structure, CSS style and JavaScript logic of the component, and is used for rendering and interaction of the component;
The configuration part of the component comprises attribute definition, attribute type, attribute default value and attribute verification rule of the component, and is used for the self definition and verification of the component;
the description of the components, including functional description of the components, methods of use, example code, notes, is for understanding and learning of the components.
3. The low code platform based component ecology application development method of claim 1 wherein the interface rules of the component comprise the following parts:
the data input and output of the assembly comprise a data source, a data model, a data format, data conversion and data verification of the assembly, and are used for data processing and transmission of the assembly;
event triggering and response of the component, including event type, event parameters, event callback and event bubbling of the component, for event processing and notification of the component;
the method call and return of the component comprise the method name, the method parameter, the method return value and the method exception of the component, and are used for executing and returning the method of the component;
The life cycle interface of the component comprises the steps of creating, mounting, updating and unloading the component and is used for the life cycle management and control of the component.
4. The low-code platform-based component ecological application development method according to claim 1, wherein the component ecological application development flow in the stage two is as follows:
initializing: initializing a development environment of the component by using a CLI tool provided by the platform, and generating a basic structure and a configuration file of the component;
Demand analysis: carrying out analysis and construction of company components based on service carding, identifying service demands and pain points, determining functions and ranges of the components, and selecting proper component types and specifications;
designing a sketch: designing UI and interaction of the components, drawing prototype diagrams and flowcharts of the components, and determining layout and logic of the components;
Coding design: writing templates, attributes and interfaces of the components; resources required by writing the components, including pages, rights, micro-streams and dependencies; using the designer and scaffold tools provided by the platform, rapidly developing and previewing the effects of the components;
joint debugging: the developer carries out real-time joint debugging through the designer, checks interaction and data transmission among the components, and debugs the functions and performances of the components;
And (3) testing and verifying: the method comprises the steps of comprehensively testing the components, including functional testing, performance testing and safety testing, ensuring the correctness and reliability of the components, collecting feedback and evaluation of users, and continuously improving the components;
And (3) issuing: the developer needs to use CLI tools provided by the platform, package component resources, generate component packages, publish components through the designer, upload component packages to a component library, or directly deploy into an application.
5. The method for developing a component ecological application based on a low code platform according to claim 1, wherein the component package in the stage two is in a zip file, and the zip file comprises the following files:
manift. Json: the metadata file of the component package comprises the name, description, version, author and label of the component package and is used for identifying and managing the component package;
page. Zip: the page file of the component package comprises page resources of the component and is used for a UI part of the component; permission. Zip: the rights file of the component package comprises rights resources of the component and is used for an access control part of the component;
microflow. Zip: the micro-stream file of the component package comprises micro-stream resources of the component and is used for a business logic part of the component;
dependency. Zip: the dependency file of the component package contains the dependent resources of the component for the associated portion of the component.
6. The method for developing component ecological application based on low-code platform according to claim 1, wherein the version management of the immutable common core component in the stage three comprises the following specific procedures: packaging the components into component packages, uploading the component packages to a component library, or directly deploying the component packages into an application; when publishing, the version number of the component needs to be specified, the semantical version specification is followed, and an x.y.z format is used, wherein x represents a major version number, y represents a minor version number and z represents a revision number;
the developer upgrades the immutable component according to the requirement or feedback, then reissues the component, upgrades the version number of the component, and the following principle needs to be followed:
if only bug of the component is repaired or performance of the component is improved, only revision number is needed to be increased;
If the functions or attributes of the components are increased, but the compatibility of the components is not affected, only the minor version number is required to be increased;
if the functionality or properties of a component are modified, resulting in a change in compatibility of the component, the major version number needs to be increased.
7. The method for developing the component ecological application based on the low-code platform according to claim 6, further comprising the step of rolling back the immutable component: the developer rolls back the immutable component through a rollback tool provided by the platform, restores the component to a certain previous version, and solves the problem or error of the component; upon rollback, it is necessary to specify the version number of the component, select the version to rollback to, and then confirm the rollback operation.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410024604.3A CN117950652A (en) | 2024-01-08 | 2024-01-08 | Component ecological application development method based on low-code platform |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410024604.3A CN117950652A (en) | 2024-01-08 | 2024-01-08 | Component ecological application development method based on low-code platform |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117950652A true CN117950652A (en) | 2024-04-30 |
Family
ID=90801225
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202410024604.3A Pending CN117950652A (en) | 2024-01-08 | 2024-01-08 | Component ecological application development method based on low-code platform |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117950652A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN118502746A (en) * | 2024-07-18 | 2024-08-16 | 杭州定川信息技术有限公司 | Method and system for quickly constructing informatization system and electronic equipment |
-
2024
- 2024-01-08 CN CN202410024604.3A patent/CN117950652A/en active Pending
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN118502746A (en) * | 2024-07-18 | 2024-08-16 | 杭州定川信息技术有限公司 | Method and system for quickly constructing informatization system and electronic equipment |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8949772B1 (en) | Dynamic model based software application development | |
| US8706771B2 (en) | Systems and methods for analyzing and transforming an application from a source installation to a target installation | |
| US20170192758A1 (en) | Method and apparatus for migration of application source code | |
| Iovino et al. | On the Impact Significance of Metamodel Evolution in MDE. | |
| US8826224B2 (en) | Apparatus and method for supporting model-driven development | |
| US9037595B2 (en) | Creating graphical models representing control flow of a program manipulating data resources | |
| US8291372B2 (en) | Creating graphical models representing control flow of a program manipulating data resources | |
| US20080276221A1 (en) | Method and apparatus for relations planning and validation | |
| CN105144088A (en) | Association of metadata with source code and applications and services premised thereon | |
| US8527254B2 (en) | Simulator engine development system and simulator engine development method | |
| EP3842975B1 (en) | Syntactical change-resistant code generation | |
| US9311077B2 (en) | Identification of code changes using language syntax and changeset data | |
| CN117950652A (en) | Component ecological application development method based on low-code platform | |
| KR20070058954A (en) | Apparatus and method for prototype development of embedded system | |
| Vicente Chicote et al. | REMM-Studio: an integrated model-driven environment for requirements specification, validation and formatting | |
| Salunkhe et al. | Automatic transformation of SysML model to event-B model for railway CCS application | |
| Wimmer et al. | On the integration of web modeling languages: Preliminary results and future challenges | |
| Julius et al. | A meta-model based environment for GRAFCET specifications | |
| US9501598B1 (en) | System and method for assertion publication and re-use | |
| Pichidtienthum et al. | Developing Module Generation for Odoo Using Concept of Low-Code Development Platform and Automation Systems | |
| Dall'Ora et al. | A common manipulation framework for transistor-level languages | |
| WO2011041246A1 (en) | Systems and methods for analyzing and transforming an application from a source installation to a target installation | |
| Schröpfer et al. | A Generic Projectional Editor for EMF Models. | |
| Wiesmayr et al. | A tool-assisted approach for user-friendly definition of fb constraints | |
| Costache et al. | Design and validation of feature-based process model tailoring: a sample implementation of PDE |
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 |