A platform development method and system based on low code

Abstract

The embodiment of the present invention provides a low-code-based platform development method and system, which relates to the technical field of platform development technology. The method includes: obtaining platform development request information, wherein the request information includes platform function information, function execution logic and scenario information, and the scenario information includes the platform usage scenario; script compiling the platform function information, the function execution logic and the scenario information through a preset self-editing program to obtain a target script; sending the target script to an executor, and sending an execution instruction to the executor to instruct the executor to execute the target script. Through the present invention, the problem of low efficiency of low-code platform development is solved, thereby achieving the effect of improving the efficiency of low-code platform development.

Description

Technical Field

[0001] The embodiments of the present invention relate to the field of low-code platform development, and specifically, to a low-code-based platform development method and system. Background Art

[0002] With the rapid development of information technology, the demand for software development is growing. Although traditional manual coding can provide highly customized solutions, it has a long development cycle, high cost, difficult maintenance, and requires high programming skills from developers. In order to solve these problems, the low-code platform came into being. It provides a visual programming environment and pre-built code modules, allowing non-professional developers to quickly build applications.

[0003] The core advantage of the low-code platform lies in its fast development process and low technical threshold. It allows developers to build applications by dragging and dropping components and configuring properties without writing a lot of code. This development method not only improves development efficiency, but also reduces development costs and makes it easier to iterate and maintain applications.

[0004] However, although low-code platforms have made significant progress in improving development efficiency, they still face some challenges in practical applications. For example, existing low-code platforms are still insufficient in handling complex business logic and customized requirements, and they also have limitations in cross-platform compatibility and performance optimization. In addition, as the scale of applications expands, how to effectively manage and optimize resource usage, and how to ensure the stability and security of applications have also become issues that low-code platforms need to solve.

[0005] In existing low-code platforms, developers usually need to perform multiple iterations in the design, compilation, and execution stages, which not only increases development time but also increases the risk of errors. In addition, when applications need to integrate with existing systems or call external services, developers often need to manually configure a large number of interfaces and parameters, which is cumbersome and error-prone.

[0006] There is currently no better solution to the above problems. Summary of the invention

[0007] The embodiments of the present invention provide a low-code-based platform development method and system to at least solve the problem of low efficiency of low-code platform development in related technologies.

[0008] According to one embodiment of the present invention, a low-code-based platform development method is provided, including:

[0009] Obtaining platform development request information, wherein the request information includes platform function information, function execution logic, and scenario information, and the scenario information includes the usage scenario of the platform;

[0010] Compiling the platform function information, the function execution logic and the scenario information into a script through a preset self-editing program to obtain a target script;

[0011] The target script is sent to an executor, and an execution instruction is sent to the executor to instruct the executor to execute the target script.

[0012] In an exemplary embodiment, before scripting the platform function information, the function execution logic, and the scenario information through a preset self-editing program to obtain a target script, the method further includes:

[0013] Obtaining a system function entry for executing the target script, wherein the system function entry is provided with a plurality of system function entries, and the script compilation is compiled based on the system function entry;

[0014] The function execution path and function execution nodes are determined according to the system function entry, and the function execution nodes are displayed through visual buttons.

[0015] In an exemplary embodiment, after sending the target script to an executor and sending an execution instruction to the executor to instruct the executor to execute the target script, the method further includes:

[0016] Acquire a compilation adjustment record of the target script, wherein the compilation adjustment record includes memory change data of a system during the compilation of the target script;

[0017] determining a memory change feature according to the memory change data;

[0018] The memory detection process is performed on the executor based on the memory change feature, and when the memory of the executor does not meet the execution requirement of the memory change data, an expansion instruction is issued.

[0019] In an exemplary embodiment, after obtaining the system function entry for executing the target script, the method further includes:

[0020] Based on the system function entry, filter system compatible plug-ins, wherein the system compatible plug-ins correspond to the system one by one;

[0021] Compile the system compatible plug-in into the target script.

[0022] In an exemplary embodiment, the scripting of the platform function information, the function execution logic, and the scenario information through a preset self-editing program to obtain a target script includes:

[0023] Parsing the platform function information, the function execution logic and the scenario information to determine the script logic order and script element positions, wherein the script elements include script subroutines and script subprocesses;

[0024] Based on the script logic sequence and the system function entry, the script element is mounted to the script element position through the self-editing program to obtain the target script.

[0025] In an exemplary embodiment, after sending the target script to the executor, the method further includes:

[0026] Performing operation monitoring on the actuator;

[0027] When garbled information is detected or the platform response time exceeds the preset threshold, an abnormal alarm will be issued.

[0028] According to another embodiment of the present invention, a low-code-based platform development system is provided, including:

[0029] A development request collection module, used to obtain platform development request information, wherein the request information includes platform function information, function execution logic and scenario information, and the scenario information includes the platform usage scenario;

[0030] A script compiling module, used to compile the platform function information, the function execution logic and the scenario information into a script through a preset self-editing program to obtain a target script;

[0031] The script execution module is used to send the target script to the executor and send an execution instruction to the executor to instruct the executor to execute the target script.

[0032] In an exemplary embodiment, it further includes:

[0033] An entry acquisition module is used to obtain a system function entry for executing the target script before script compiling the platform function information, the function execution logic and the scenario information through a preset self-editing program to obtain the target script, wherein the system function entry is provided with a plurality of system function entries, and the script compilation is compiled based on the system function entry;

[0034] The path node determination module is used to determine the function execution path and function execution nodes according to the system function entry, and the function execution nodes are displayed through visual buttons.

[0035] According to yet another embodiment of the present invention, a computer-readable storage medium is provided, in which a computer program is stored, wherein the computer program is configured to execute the steps of any one of the above method embodiments when run.

[0036] According to yet another embodiment of the present invention, there is provided an electronic device, including a memory and a processor, wherein the memory stores a computer program, and the processor is configured to run the computer program to execute the steps in any one of the above method embodiments.

[0037] Through the present invention, the development efficiency of the low-code platform and the quality of the application are improved through automated script compilation, optimized resource management and efficient error detection mechanism. Through the present invention, developers can build and deploy applications more conveniently while ensuring the performance and security of the application. Therefore, the problem of low development efficiency of the low-code platform can be solved, and the effect of improving the platform development efficiency can be achieved. BRIEF DESCRIPTION OF THE DRAWINGS

[0038] Figure 1 is a flow chart of a low-code based platform development method according to an embodiment of the present invention;

[0039] Figure 2 It is a structural block diagram of a low-code based platform development system according to an embodiment of the present invention. DETAILED DESCRIPTION

[0040] The technical solutions in the embodiments of the present application will be described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, rather than all of the embodiments.

[0041] In the following, the terms "first", "second", etc. are used for descriptive purposes only and are not to be understood as indicating or implying relative importance or implicitly indicating the number of the indicated technical features. Thus, a feature defined as "first", "second", etc. may explicitly or implicitly include one or more of the features. In the description of this application, unless otherwise specified, "plurality" means two or more.

[0042] In addition, in the present application, directional terms such as "up", "down", "left" and "right" may be defined including but not limited to the orientation relative to the schematic placement of the components in the drawings. It should be understood that these directional terms may be relative concepts, which are used for relative description and clarification, and may change accordingly according to the change in the orientation of the components in the drawings.

[0043] In this application, unless otherwise specified or limited, the term "connection" should be understood in a broad sense. For example, "connection" can be a fixed connection, a detachable connection, or an integral connection; it can be a direct connection or an indirect connection through an intermediate medium. In addition, the term "coupling" can be a way of achieving electrical connection for signal transmission.

[0044] As used herein, "about," "substantially," or "approximately" includes the stated value and an average value that is within an acceptable range of variation from the particular value as determined by one of ordinary skill in the art taking into account the measurements in question and the errors associated with the measurement of the particular quantity (i.e., the limitations of the measurement system).

[0045] In this embodiment, a low-code based platform development method is provided. Figure 1 is a flowchart of a low-code-based platform development according to an embodiment of the present invention, such as Figure 1 As shown, the process includes the following steps:

[0046] Step S101, obtaining platform development request information, wherein the request information includes platform function information, function execution logic and scenario information, and the scenario information includes the usage scenario of the platform;

[0047] In this embodiment, the user's requirements for the platform during the platform development process are obtained to provide guidance for the final platform structure and functions.

[0048] Among them, the request information can be the relevant requirements input by the user through the request input end of the self-editing program. These requirements include the functions that the user hopes the platform to have (i.e., platform function information), the execution logic of the functions, and their expected usage scenarios. The functions of the platform can be platform scalability, automated workflow, integration capabilities, multi-language and localization support, etc., and the usage scenarios can be recruitment, soliciting customers, travel, accommodation, take-out and other usage scenarios; correspondingly, the platform's operating system can be mobile phone systems such as Android / IOS, or PC systems such as Windows and Linux, or other types of systems; it should be noted that since the system logic, data interface, etc. of the mobile phone system and the PC system are different, it is necessary to determine in advance the system information that the platform needs to run, so that the self-editing program can match the corresponding access plug-in according to the different systems to ensure the correct operation of the system.

[0049] In addition, after obtaining the user's needs, it is necessary to organize the functional requirements submitted by the user, clarify the purpose, input, output and relationship with other functions of each function, determine the information architecture of the function, including data models, user interface elements and interaction processes, and the execution logic of each function, such as business rules, algorithms and processing flows, and create flowcharts or pseudocodes for complex logic to facilitate understanding and implementation; in particular, when elaborating on relevant functions, it is necessary to collect and analyze the usage scenarios described by users. These scenarios need to describe the application of the platform in actual work, and determine the relationship between the context of the scenarios, such as user roles, environmental conditions and expected user experience, in order to facilitate the integration of functional information The information, execution logic and scenario information are integrated into a complete development request, and the requirements are prioritized according to business value, urgency of user needs and development difficulty, so as to provide a reference for the development roadmap and iteration plan and accelerate the efficiency of platform development. It should be noted that the above-mentioned sorting process can automatically sort out the information input by the user through the automatic recognition and sorting model of the self-editing program. In this application, NLP natural language processing technology is used to implement it. Models related to this technology include machine learning models (SVM, random forest, etc.), deep learning models, etc., which can be used in the solution of this application. Of course, visualization tools for text analysis can also be considered to assist in the implementation, and there is no restriction here.

[0050] Step S102, script compiling the platform function information, the function execution logic and the scenario information through a preset self-editing program to obtain a target script;

[0051] In this embodiment, script compilation includes dragging or mounting pre-compiled functional modules to the main program through a self-editing program, and performing syntax checking, code optimization, and error correction on the compiled script. In particular, before compilation, it can also include testing the pre-compiled functional modules, and after obtaining the target script, testing and verifying the target script, wherein the test verification process includes unit testing, integration testing, and scenario testing to verify whether the target script meets the functional requirements, whether the execution logic is correct, and whether it can work normally in all expected scenarios.

[0052] Among them, taking the compilation of the recruitment platform as an example, the UI components required for the recruitment platform are dragged and dropped onto the design canvas (corresponding to the aforementioned main process), such as search bars, tables, forms, etc., and then the business logic of the application is defined through the business logic editor in the self-editing program according to the pre-organized business logic and function execution logic, such as job matching algorithm, notification sending mechanism, etc., and the corresponding event processing code is generated, such as job application, resume upload, etc., and then the system interface plug-in of the application is configured according to the usage scenario, such as interface adaptation of mobile and PC terminals, to obtain an initial script that can be run; then the initial script is tested, and the initial script is adjusted according to the test results to obtain the target script.

[0053] It should be noted that the self-editing program includes at least an automatic code generation program, a multi-platform interface support program, a real-time preview and debugging program, and inherited API management. In particular, it can also include a visualization program, a section designer, a script engine, a packaging tool, a testing framework, etc.

[0054] Step S103: sending the target script to an executor, and sending an execution instruction to the executor to instruct the executor to execute the target script.

[0055] In this embodiment, the executor performs relevant operations according to the target script to complete the development of the platform; this process is developed based on low code, so it is suitable for the development of lightweight functional platforms, which effectively speeds up the efficiency of platform development. At the same time, since the development process is automatically based on the self-editing program, the manual requirements are greatly reduced, that is, the platform development and compilation are performed automatically according to the relevant functional requirements through the self-editing program, which reduces manual intervention and improves the accuracy of platform development.

[0056] Through the above steps, the development efficiency of the low-code platform and the quality of applications are improved through automated script compilation, optimized resource management and efficient error detection mechanism, which solves the problem of low-code platform development efficiency and improves the efficiency of low-code platform development.

[0057] The execution subject of the above steps may be a mobile terminal, etc., but is not limited thereto.

[0058] In an optional embodiment, before scripting the platform function information, the function execution logic, and the scenario information through a preset self-editing program to obtain a target script, the method further includes:

[0059] Step S10201, obtaining a system function entry for executing the target script, wherein the system function entry is provided with a plurality of system function entries, and the script compilation is compiled based on the system function entry;

[0060] Step S10202, determining a function execution path and a function execution node according to the system function entry, and the function execution node is displayed through a visual button.

[0061] In this embodiment, the system function entry is obtained to facilitate the definition of the interface and parameters of the system entry, so that it can be called when the script is compiled. At the same time, by supporting multiple function entries, the usage requirements in different scenarios can be met.

[0062] Among them, after obtaining the system function entrance, it is necessary to classify the system function entrance according to the platform's function type, user role or other logic to facilitate subsequent targeted parameter definition; the function execution path includes the path from the system function entrance to the completion of the function execution, and correspondingly, the function execution node includes each key node defined on the function execution path, such as data verification, business processing, user interaction, etc.; and displaying the function execution node through a visual button can facilitate users to perform functional operations on the platform; it should be noted that when designing the path, it is necessary to impose rule constraints on the data flow configuration, such as data verification, data conversion, data storage, etc. The constraint process specifically includes determining the data type and data volume that the application needs to process according to the platform requirements input by the user, and then establishing a data dictionary, which records the data type, format and constraint relationship of each data field. For example, taking the recruitment platform as an example:

[0063] Data type: integer;

[0064] Constraints: primary key;

[0065] Constraint formula: PrimaryKey(ProductID);

[0066] Data type: string;

[0067] Constraints: not empty, length between 3 and 100 characters;

[0068] Constraint formula: NotNull() + Length(ProductName, 3, 100);

[0069] Data type: integer;

[0070] Constraints: Not empty, the number of words in the resume must be greater than or equal to 0 and less than or equal to 9999;

[0071] Constraint formula: NotNull() + Range(QuantityBiographicalnotes, 0, 9999);

[0072] The same goes for other constraints.

[0073] In an optional embodiment, after sending the target script to the executor and sending an execution instruction to the executor to instruct the executor to execute the target script, the method further includes:

[0074] Step S104, obtaining a compilation adjustment record of the target script, wherein the compilation adjustment record includes memory change data of the system during the compilation process of the target script;

[0075] Step S105, determining memory change characteristics according to the memory change data;

[0076] Step S106: Perform memory detection processing on the executor based on the memory change characteristics, and issue a capacity expansion instruction when the memory of the executor does not meet the execution requirements of the memory change data.

[0077] In this embodiment, by monitoring the changes in memory during the compilation process, the memory value that may be required during execution is determined, and the memory status of the executor is pre-detected to ensure that the subsequent executor can accurately run the target script.

[0078] Among them, the compilation adjustment record specifically includes information such as memory usage peak, average usage rate, memory leak, etc. At the same time, the memory usage pattern and potential problems in the execution process are determined based on the data to facilitate the adjustment of the script; then, based on the memory change data, the typical characteristics of memory usage are identified, such as rapid growth, periodic fluctuations, etc., and the identified characteristics are matched with the known memory usage patterns to better understand the reasons for memory changes. At this time, statistical or machine learning techniques can also be used to predict the long-term trend of memory usage and timely alarm for possible operational anomalies; during the memory detection process, when it is found that the executor's memory does not meet the execution requirements of the memory change data, such as insufficient memory or memory leak, it is determined whether expansion is needed. The expansion instruction includes information such as the expansion size, time window, priority, etc. After receiving the expansion instruction, the system's resource management module schedules available resources to meet the executor's memory requirements. At the same time, the executor allocates new memory resources according to the expansion instruction to ensure the stable operation of the application.

[0079] In an optional embodiment, after obtaining the system function entry for executing the target script, the method further includes:

[0080] Step S102011, based on the system function entry, filter system compatible plug-ins, wherein the system compatible plug-ins correspond to the system one by one;

[0081] Step S102012, compile the system compatible plug-in into the target script.

[0082] In this embodiment, when selecting a compatible plug-in, it is necessary to confirm the dependencies of the plug-in to ensure that these dependencies already exist in the system or can be automatically installed, where the dependencies include specific libraries (such as mathematical libraries, image processing libraries) or frameworks (such as NET Framework, Spring), etc.; after determining the compatible plug-in, update the system configuration file to associate the configuration of the plug-in with the system function entry, and define a clear interface for the plug-in to ensure that the plug-in can interact with the system function entry correctly.

[0083] In an optional embodiment, the scripting of the platform function information, the function execution logic, and the scenario information through a preset self-editing program to obtain a target script includes:

[0084] Step S1021, parsing the platform function information, the function execution logic and the scenario information to determine the script logic order and script element positions, wherein the script elements include script subroutines and script subprocesses;

[0085] Step S1022, based on the script logic sequence and the system function entry, the script element is mounted to the script element position through the self-editing program to obtain the target script.

[0086] In this embodiment, the sub-process includes complex business logic or workflow, and the sub-program includes predefined functional modules or custom code blocks; after completing the mounting action, necessary parameters and configuration items are configured for the mounted script elements, and if the script elements depend on external resources or services, dependency injection is performed; then all mounted script elements are merged to generate a complete target script, and the synthesized script is optimized to improve execution efficiency and performance. In particular, an error handling mechanism needs to be added to the script to ensure that clear feedback can be given when execution fails.

[0087] In an optional embodiment, after sending the target script to the executor, the method further includes:

[0088] Step S107, monitoring the operation of the actuator;

[0089] Step S108, when garbled information is detected or the platform response time exceeds a preset threshold, an abnormal alarm is issued.

[0090] In this embodiment, the operation monitoring mainly monitors the performance indicators of the executor, such as CPU usage, memory consumption, disk I / O, etc., and the operation log of the executor, including the execution time of the script, the execution result and any system messages. In some environments, it also includes garbled information caused by coding problems or data corruption, and whether the response time of the platform is within the preset service level agreement (SLA) threshold. If the above-mentioned memory consumption, garbled information is too much or the reaction time exceeds the threshold, it is judged that the target script may be abnormal, and an abnormal alarm is required at this time; in particular, when making an abnormal judgment, the functional modules in the target script and the reaction time threshold of the corresponding functional modules, CPU usage, memory consumption, disk I / O and the number of garbled codes that may appear in the functional modules can be determined according to the platform development request information and historical data in the target script, and then according to the reaction time threshold and the number of garbled codes, the target script is judged to be abnormal. According to the mapping relationship between the functional module and the threshold condition, the module-threshold condition model is constructed, and then the fault probability of the garbled information and platform response time data currently monitored is calculated through the model. When the fault probability is within the preset range, the data is judged to be normal, otherwise it is judged to be abnormal; or the standard matrix is ​​directly compiled according to the mapping relationship, and the garbled information and platform response time data actually monitored are compiled into a measured matrix, and then the correlation and similarity between the standard matrix and the measured matrix are calculated. When the correlation and similarity are both within the preset range, the data is judged to be normal, otherwise it is judged to be abnormal; of course, before performing the probability calculation, the garbled information and platform response time data actually monitored need to be encoded to facilitate the model to calculate. The following is an exemplary code for probability calculation: response_time_probability=

[0091] max(0, (threshold.response_time_threshold - monitoring_data.response_time) / threshold.response_time_threshold)

[0092] garbage_code_probability = max(0, (threshold.garbage_code_threshold- monitoring_data.garbage_code_count) / threshold.garbage_code_threshold).

[0093] Through the description of the above implementation methods, those skilled in the art can clearly understand that the method according to the above embodiment can be implemented by means of software plus a necessary general hardware platform, and of course can also be implemented by hardware, but in many cases the former is a better implementation method. Based on such an understanding, the technical solution of the present invention, or the part that contributes to the prior art, can be embodied in the form of a software product, which is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk), and includes a number of instructions for enabling a terminal device (which can be a mobile phone, computer, server, or network device, etc.) to execute the methods described in each embodiment of the present invention.

[0094] In this embodiment, a low-code-based platform development system is also provided, which is used to implement the above-mentioned embodiments and preferred implementation modes, and will not be repeated here. As used below, the term "module" can implement a combination of software and / or hardware for a predetermined function. Although the devices described in the following embodiments are preferably implemented in software, the implementation of hardware, or a combination of software and hardware, is also possible and conceivable.

[0095] Figure 2 is a structural block diagram of a low-code based platform development system according to an embodiment of the present invention, such as Figure 2 As shown, the system includes:

[0096] The development request collection module 21 is used to obtain platform development request information, wherein the request information includes platform function information, function execution logic and scenario information, and the scenario information includes the platform usage scenario;

[0097] A script compiling module 22, used for compiling the platform function information, the function execution logic and the scenario information into a script through a preset self-editing program to obtain a target script;

[0098] The script execution module 23 is used to send the target script to the executor and send an execution instruction to the executor to instruct the executor to execute the target script.

[0099] In an optional embodiment, it also includes:

[0100] An entry acquisition module is used to obtain a system function entry for executing the target script before script compiling the platform function information, the function execution logic and the scenario information through a preset self-editing program to obtain the target script, wherein the system function entry is provided with a plurality of system function entries, and the script compilation is compiled based on the system function entry;

[0101] The path node determination module is used to determine the function execution path and function execution nodes according to the system function entry, and the function execution nodes are displayed through visual buttons.

[0102] It should be noted that the above modules can be implemented by software or hardware. For the latter, it can be implemented in the following ways, but not limited to: the above modules are all located in the same processor; or the above modules are located in different processors in any combination.

[0103] An embodiment of the present invention further provides a computer-readable storage medium, in which a computer program is stored, wherein the computer program is configured to execute the steps of any of the above method embodiments when running.

[0104] In an exemplary embodiment, the computer-readable storage medium may include, but is not limited to, various media that can store computer programs, such as a USB flash drive, a read-only memory (ROM), a random access memory (RAM), a mobile hard disk, a magnetic disk or an optical disk.

[0105] An embodiment of the present invention further provides an electronic device, including a memory and a processor, wherein a computer program is stored in the memory, and the processor is configured to run the computer program to execute the steps in any one of the above method embodiments.

[0106] In an exemplary embodiment, the electronic device may further include a transmission device and an input / output device, wherein the transmission device is connected to the processor, and the input / output device is connected to the processor.

[0107] Through the description of the above implementation methods, technical personnel in the relevant field can clearly understand that for the convenience and simplicity of description, only the division of the above-mentioned functional modules is used as an example. In actual applications, the above-mentioned functions can be assigned to different functional modules as needed, that is, the internal structure of the device can be divided into different functional modules to complete all or part of the functions described above.

[0108] In the several embodiments provided in the present application, it should be understood that the disclosed devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic, for example, the division of modules or 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 device, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0109] The units described as separate components may or may not be physically separated, and the components shown as units may be one physical unit or multiple physical units, that is, they may be located in one place or distributed in multiple different places. Some or all of the units may be selected according to actual needs to achieve the purpose of the present embodiment.

[0110] In addition, each functional unit in each embodiment of the present application 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-mentioned integrated unit may be implemented in the form of hardware or in the form of software functional units.

[0111] 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 readable storage medium. Based on this understanding, the technical solution of the embodiment of the present application 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, which is stored in a storage medium and includes several instructions to enable a device (which can be a single-chip microcomputer, chip, etc.) or a processor (processor) to execute all or part of the steps of the methods of each embodiment of the present application. The aforementioned storage medium includes: U disk, mobile hard disk, read only memory (ROM), random access memory (RAM), disk or optical disk and other media that can store program code.

[0112] The above contents are only specific implementation methods of the present application, but the protection scope of the present application is not limited thereto. Any changes or substitutions within the technical scope disclosed in the present application shall be included in the protection scope of the present application. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.

Claims

1. A low-code-based platform development method, characterized in that: include: Obtaining platform development request information, wherein the request information includes platform function information, function execution logic, and scenario information, and the scenario information includes the usage scenario of the platform; Compiling the platform function information, the function execution logic and the scenario information into a script through a preset self-editing program to obtain a target script; Sending the target script to an executor, and sending an execution instruction to the executor to instruct the executor to execute the target script; Before scripting the platform function information, the function execution logic and the scenario information through a preset self-editing program to obtain a target script, the method further includes: Obtaining a system function entry for executing the target script, wherein the system function entry is provided with a plurality of system function entries, and the script compilation is compiled based on the system function entry; Determine a function execution path and a function execution node according to the system function entry, and display the function execution node through a visual button; Among them, determining the function execution path according to the system function entry includes: determining the data type and data volume that the application needs to process according to the platform requirements input by the user, and establishing a data dictionary, and performing rule constraints on the data flow configuration according to the data dictionary. The data dictionary records the data type, format and constraint relationship of each data field.

2. The method according to claim 1, characterized in that After sending the target script to the executor and sending an execution instruction to the executor to instruct the executor to execute the target script, the method further includes: Acquire a compilation adjustment record of the target script, wherein the compilation adjustment record includes memory change data of a system during the compilation of the target script; determining a memory change feature according to the memory change data; The memory detection process is performed on the executor based on the memory change feature, and when the memory of the executor does not meet the execution requirement of the memory change data, an expansion instruction is issued.

3. The method according to claim 1, characterized in that After obtaining the system function entry for executing the target script, the method further includes: Based on the system function entry, filter system compatible plug-ins, wherein the system compatible plug-ins correspond to the system one by one; Compile the system compatible plug-in into the target script.

4. The method according to claim 1, characterized in that: The scripting of the platform function information, the function execution logic and the scenario information by a preset self-editing program to obtain a target script includes: Parsing the platform function information, the function execution logic and the scenario information to determine the script logic order and script element positions, wherein the script elements include script subroutines and script subprocesses; Based on the script logic sequence and the system function entry, the script element is mounted to the script element position through the self-editing program to obtain the target script.

5. The method according to claim 1, characterized in that After sending the target script to the executor, the method further includes: Performing operation monitoring on the actuator; When garbled information is detected or the platform response time exceeds the preset threshold, an abnormal alarm will be issued.

6. A low-code based platform development system, characterized in that: include: A development request collection module, used to obtain platform development request information, wherein the request information includes platform function information, function execution logic and scenario information, and the scenario information includes the platform usage scenario; A script compiling module, used to compile the platform function information, the function execution logic and the scenario information into a script through a preset self-editing program to obtain a target script; A script execution module, used to send the target script to an executor and send an execution instruction to the executor to instruct the executor to execute the target script; Among them, it also includes: An entry acquisition module is used to obtain a system function entry for executing the target script before script compiling the platform function information, the function execution logic and the scenario information through a preset self-editing program to obtain the target script, wherein the system function entry is provided with a plurality of system function entries, and the script compilation is compiled based on the system function entry; A path node determination module, used to determine a function execution path and a function execution node according to the system function entry, wherein the function execution node is displayed through a visual button; Among them, determining the function execution path according to the system function entry includes: determining the data type and data volume that the application needs to process according to the platform requirements input by the user, and establishing a data dictionary, and performing rule constraints on the data flow configuration according to the data dictionary. The data dictionary records the data type, format and constraint relationship of each data field.

7. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program, wherein the computer program is configured to execute the method according to any one of claims 1 to 5 when executed.

8. An electronic device comprising a memory and a processor, characterized in that: A computer program is stored in the memory, and the processor is configured to run the computer program to perform the method according to any one of claims 1 to 5.

Images