Method and device for customizing component engine based on low-code platform
Patent Information
- Application Number
- CN202410821887.4
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-06-25
- Publication Date
- 2024-11-12
Smart Images

Figure CN118939253A_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the field of WEB applications, and in particular to a method and device for a custom component engine based on a low-code platform. Background Art
[0002] With the accelerated advancement of enterprise informatization and digital transformation, low-code platforms enable developers to quickly build applications by dragging and configuring by providing graphical interfaces and predefined components, thereby reducing the difficulty and threshold of software development and improving development efficiency.
[0003] However, the existing low-code platforms still have certain deficiencies in supporting custom components. When faced with some specific business scenarios or personalized needs, the predefined components provided by the low-code platform may not meet the requirements. At this time, it is necessary to develop components that meet your own business needs, but the existing low-code platforms often lack effective support and guarantees in the development, management and operation of custom components. Summary of the invention
[0004] In order to overcome the shortcomings of the above technologies, the present invention provides a method and device for a custom component engine based on a low-code platform, which enables users to flexibly develop, configure, run and manage custom business components, greatly expanding the functionality and flexibility of the low-code platform.
[0005] The technical solution adopted by the present invention to overcome the technical problems is: A method for a custom component engine based on a low-code platform, characterized by comprising: S1. Pre-introduce the custom component engine service into the low-code platform; S2. Access the custom component information configuration page of the custom component engine service to maintain basic information; S3. The low-code platform party writes the code of the custom component and completes the component code configuration; S4. Compile and output the configured component code into the final front-end code that can be directly referenced, parsed and executed by the browser; S5. The low-code platform uses custom components through API interface calls.
[0006] Furthermore, the information of the target low-code platform registered in step S1 includes workspace, component dependencies, public status, and global functions.
[0007] Furthermore, the basic information in step S2 includes: name, icon, version, description, development language, usage framework information, application information, project information, and workspace information.
[0008] Furthermore, the custom component information configuration page in step S2 is embedded in the low-code platform or the custom component information configuration page is accessed as a link.
[0009] Further, step S3 includes the following steps: S31. Upload the already written component code files and directories by uploading files to create and update component source files; S32. Edit the code online through CloudIDE to generate component code source files.
[0010] Furthermore, when writing the component code file in step S31, the external dependencies, public properties, and methods of the target low-code platform designer are integrated; when editing the code online through CloudIDE in step S32, the system's compilation engine service is called to synchronously compile the online code into a js format file that can be run in the browser and preview the effect in real time on the page. After CloudIDE completes the online code editing, the code source file is generated for storage and maintenance.
[0011] Furthermore, the component code configured in step S4 includes a script entry file, an HTML template file, a sample file, a static resource file, and a dependency configuration file. When the compiled output is a final front-end code that can be directly referenced, parsed, and executed by a browser, the configured component code is processed according to the development language, mining machine, and operating environment information selected by the component.
[0012] Furthermore, the file format for processing the configured component code is js or jsx or ts or tsx or wasm script file, and the processing content includes: removing redundant code, merging the same functional modules, compressing code size, and introducing functional attributes of the low-code platform.
[0013] Furthermore, the API interface in step S5 supports RESTful protocol, Api protocol, and SOAP protocol.
[0014] On the other hand, the present invention also relates to a device of a custom component engine based on a low-code platform, comprising a processor, a communication interface, a memory and a communication bus, wherein the processor, the communication interface and the memory communicate with each other through the communication bus; wherein: The memory is used to store computer programs; The processor is configured to execute, by running a program stored in the memory: Pre-introduce custom component engine services into the low-code platform; Access the custom component information configuration page of the custom component engine service to maintain basic information; The low-code platform party writes the code of the custom component and completes the component code configuration; Compile and output the configured component code into the final front-end code that can be directly referenced, parsed and executed by the browser; The low-code platform uses custom components through API interface calls.
[0015] The beneficial effects of the present invention are: solving the deficiencies of existing low-code platforms in custom components, and providing more flexible, efficient and stable custom component development and management solutions. Through the system and method implemented by the present invention, users can flexibly design and develop custom components that meet their own business needs, and seamlessly integrate them into the applications of the low-code platform, thereby achieving rapid iteration and personalized customization of software development. Through the custom component engine of the present invention, users can easily create custom components that meet their own business needs, greatly improving the flexibility and scalability of the low-code platform. At the same time, the rich functions and tools provided by the engine also greatly reduce the user's development difficulty and cost, improve development efficiency, and realize an efficient, flexible and easy-to-use custom component development method. BRIEF DESCRIPTION OF THE DRAWINGS
[0016] Figure 1 The present invention is a flow chart of the method. DETAILED DESCRIPTION
[0017] The following is combined with Figure 1 The preferred embodiments of the present invention are described in detail so that the advantages and features of the present invention can be more easily understood by those skilled in the art, thereby making a clearer and more definite definition of the protection scope of the present invention.
[0018] In the description of the present invention, it should be noted that the embodiments described in the present invention are only part of the embodiments of the present invention, rather than all of the embodiments; based on the embodiments in the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present invention.
[0019] The terms "first", "second", etc. in the specification and claims of this article and the above-mentioned drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It should be understood that the data used in this way can be interchanged where appropriate, so that the embodiments of this article described here can be implemented in an order other than those illustrated or described here. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusions, for example, a process, method, device, product or equipment that includes a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or equipment.
[0020] Example 1 A method for a custom component engine based on a low-code platform, characterized by comprising: S1. Pre-introduce the low-code platform into the custom component engine service to be able to use the API functions of the engine and maintain custom component data.
[0021] S2. Access the custom component information configuration page of the custom component engine service to maintain basic information.
[0022] S3. The low-code platform party writes the code of the custom component and completes the component code configuration.
[0023] S4. Compile and output the configured component code into the final front-end code that can be directly referenced, parsed and executed by the browser.
[0024] S5. The low-code platform uses custom components through API interface calls.
[0025] It significantly improves the efficiency and flexibility of software development and meets the needs of enterprises for rapid iteration and personalized customization. Through custom components, custom components that meet business needs can be quickly created. Through custom component design, users can flexibly create custom components that meet business needs by manually writing code. The component configuration unit is responsible for building the environment, dependencies, properties, version information, etc. required for the operation of the integrated components; the designed components are uniformly version controlled and authorized to ensure the stability, availability and security of the components. The advantage of the present invention is that it can be embedded into an existing low-code platform at a low cost, reducing the difficulty of maintaining the low-code platform, greatly improving the freedom and scalability of the low-code platform components, and at the same time improving the efficiency of software development and the ability to respond to business needs.
[0026] In this embodiment, the information registered in the target low-code platform in step S1 includes workspace, component dependencies, public status, and global functions.
[0027] In this embodiment, the basic information in step S2 includes: name, Icon, version, description, development language, usage framework information, application information, project information, and workspace information.
[0028] In this embodiment, the custom component information configuration page in step S2 is embedded in the low-code platform or the custom component information configuration page is accessed as a link. The information configuration page is maintained by the development team and can be embedded in the low-code platform for use or accessed as a link.
[0029] In this embodiment, step S3 includes the following steps: S31. Upload the written component code files and directories through file upload to create and update component source files.
[0030] S32. Generate component code source files by editing the code online through CloudIDE. The uploaded code source files need to meet specific file\directory specifications based on the configured component development language, framework, operating environment and other information, and be successfully uploaded after being tested by code quality tools (such as SonarQubue, DeepScan, etc.). Commonly used CloudIDEs include vscode-server, TitanIDE, etc.; the system will generate different component templates based on commonly used front-end frameworks (React, Vue.js, Angular, etc.) to facilitate developers to develop quickly.
[0031] When writing component code files in step S31, the external dependencies, public properties, and methods of the target low-code platform designer are integrated; when editing the code online through CloudIDE in step S32, the system's compilation engine service is called to synchronously compile the online code into a js format file that can be run in the browser and preview the effect in real time on the page, providing the function of previewing input parameters to the preview component to observe the latest effect. After CloudIDE completes online code editing, it generates a code source file for storage and maintenance. Components that upload code source files can also be secondary edited and subsequently maintained through CloudIDE online development.
[0032] In this embodiment, the component code configured in step S4 includes a script entry file, an html template file, a sample file, a static resource file, and a dependency configuration file. When the compiled output is the final front-end code that can be directly referenced, parsed, and executed by the browser, the configured component code is processed according to the development language, mining machine, and operating environment information selected by the component.
[0033] In this embodiment, the file format for processing the configured component code is js or jsx or ts or tsx or wasm script file, and the processing content includes: removing redundant code, merging the same functional modules, compressing the code volume, introducing the functional attributes of the low-code platform, and ultimately ensuring that the component logical relationship and interactive behavior generated after compilation are correct.
[0034] In this embodiment, the API interface in step S5 supports the RESTful protocol, the Api protocol, and the SOAP protocol. The access reference module is the key part of the system responsible for docking with the low-code platform. It allows developers to easily integrate the system services, APIs, or custom codes, thereby expanding the functionality and applicability of the low-code platform. In the business process of the low-code platform, the API provided by the system is accessed, so that custom components generated by the system can be used just like the built-in components of the low-code platform.
[0035] Example 2 A device for a custom component engine based on a low-code platform, comprising a processor, a communication interface, a memory and a communication bus, wherein the processor, the communication interface and the memory communicate with each other through the communication bus; wherein: The memory is used to store computer programs; The processor is configured to execute, by running a program stored in the memory: Pre-introduce custom component engine services into the low-code platform.
[0036] Visit the custom component information configuration page of the custom component engine service to maintain basic information.
[0037] The low-code platform party writes the code of the custom component and completes the component code configuration.
[0038] Compile and output the configured component code into the final front-end code that can be directly referenced, parsed and executed by the browser.
[0039] The low-code platform uses custom components through API interface calls.
[0040] It should be understood that in the various embodiments of this document, the size of the serial numbers of the above-mentioned processes does not mean the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this document.
[0041] It should also be understood that in the embodiments of this document, the term "and / or" is only a description of the association relationship of the associated objects, indicating that three relationships may exist. For example, A and / or B can represent: A exists alone, A and B exist at the same time, and B exists alone. In addition, the character " / " in this document generally indicates that the associated objects before and after are in an "or" relationship.
[0042] Those of ordinary skill in the art will appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of the two. In order to clearly illustrate the interchangeability of hardware and software, the composition and steps of each example have been generally described in terms of function in the above description. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of this article.
[0043] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.
[0044] In the several embodiments provided herein, it should be understood that the disclosed systems, devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic, for example, the division of the units is only a logical function division, and there may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. In addition, the mutual coupling or direct coupling or communication connection shown or discussed can be an indirect coupling or communication connection through some interfaces, devices or units, or can be electrical, mechanical or other forms of connection.
[0045] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the embodiments of this article.
[0046] In addition, each functional unit in each embodiment of this invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above integrated unit may be implemented in the form of hardware or in the form of software functional unit.
[0047] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this article is essentially or the part that contributes to the prior art, or all or part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium, including a number of instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) to perform all or part of the steps of the method described in each embodiment of this article. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), disk or optical disk and other media that can store program codes.
[0048] Finally, it should be noted that the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art can still modify the technical solutions described in the aforementioned embodiments or replace some of the technical features therein by equivalents. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention shall be included in the protection scope of the present invention.
Claims
1. A method for a custom component engine based on a low-code platform, characterized in that: include: S1. Pre-introduce the custom component engine service into the low-code platform; S2. Access the custom component information configuration page of the custom component engine service to maintain basic information; S3. The low-code platform party writes the code of the custom component and completes the component code configuration; S4. Compile and output the configured component code into the final front-end code that can be directly referenced, parsed and executed by the browser; S5. The low-code platform uses custom components through API interface calls.
2. The method, device and storage medium for a custom component engine based on a low-code platform according to claim 1, characterized in that: The information of the target low-code platform registered in step S1 includes workspace, component dependencies, public status, and global functions.
3. The method, device and storage medium for a custom component engine based on a low-code platform according to claim 1, characterized in that: The basic information in step S2 includes: name, icon, version, description, development language, framework information, application information, project information, and workspace information.
4. The method, device and storage medium for a custom component engine based on a low-code platform according to claim 1, characterized in that: The custom component information configuration page in step S2 is embedded in the low-code platform or the custom component information configuration page is accessed as a link.
5. The method, device and storage medium for a custom component engine based on a low-code platform according to claim 1, characterized in that: Step S3 includes the following steps: S31. Upload the already written component code files and directories by uploading files to create and update component source files; S32. Edit the code online through CloudIDE to generate component code source files.
6. The method, device and storage medium for a custom component engine based on a low-code platform according to claim 5, characterized in that: When writing the component code file in step S31, the external dependencies, public properties, and methods of the target low-code platform designer are integrated; when editing the code online through CloudIDE in step S32, the system's compilation engine service is called to synchronously compile the online code into a js format file that can be run in the browser and preview the effect in real time on the page. After CloudIDE completes the online code editing, the code source file is generated for storage and maintenance.
7. The method, device and storage medium for a custom component engine based on a low-code platform according to claim 1, characterized in that: The component code configured in step S4 includes script entry files, html template files, sample files, static resource files, and dependent configuration files. When the compiled output is the final front-end code that can be directly referenced, parsed, and executed by the browser, the configured component code is processed according to the development language, mining machine, and operating environment information selected by the component.
8. The method, device and storage medium for a custom component engine based on a low-code platform according to claim 7, characterized in that: The file format for processing the configured component code is js or jsx or ts or tsx or wasm script file. The processing content includes: removing redundant code, merging modules with the same function, compressing code size, and introducing functional attributes of the low-code platform.
9. The method, device and storage medium for a custom component engine based on a low-code platform according to claim 1, characterized in that: The API interface in step S5 supports RESTful protocol, Api protocol, and SOAP protocol.
10. A device for a custom component engine based on a low-code platform, characterized in that: It includes a processor, a communication interface, a memory and a communication bus, wherein the processor, the communication interface and the memory communicate with each other through the communication bus; wherein: The memory is used to store computer programs; The processor is configured to execute, by running a program stored in the memory: Pre-introduce custom component engine services into the low-code platform; Access the custom component information configuration page of the custom component engine service to maintain basic information; The low-code platform party writes the code of the custom component and completes the component code configuration; Compile and output the configured component code into the final front-end code that can be directly referenced, parsed and executed by the browser; The low-code platform uses custom components through API interface calls.
